diff --git a/src/YesSql.Abstractions/IIdGenerator.cs b/src/YesSql.Abstractions/IIdGenerator.cs
index 283e10840..b3d2c6cf2 100644
--- a/src/YesSql.Abstractions/IIdGenerator.cs
+++ b/src/YesSql.Abstractions/IIdGenerator.cs
@@ -16,11 +16,24 @@ public interface IIdGenerator
         /// <param name="store">The store that this <see cref="IIdGenerator"/> instance is assigned to.</param>
         Task InitializeAsync(IStore store, CancellationToken cancellationToken = default);
 
+        /// <summary>
+        /// Invoked when the underlying store is created.
+        /// </summary>
+        /// <param name="store">The store that this <see cref="IIdGenerator"/> instance is assigned to.</param>
+        [Obsolete($"Instead, utilize the {nameof(InitializeAsync)} method with a CancellationToken parameter. This current method is slated for removal in upcoming releases.")]
+        Task InitializeAsync(IStore store);
+
         /// <summary>
         /// Initializes a document collection.
         /// </summary>
         Task InitializeCollectionAsync(IConfiguration configuration, string collection, CancellationToken cancellationToken = default);
 
+        /// <summary>
+        /// Initializes a document collection.
+        /// </summary>
+        [Obsolete($"Instead, utilize the {nameof(InitializeCollectionAsync)} method with a CancellationToken parameter. This current method is slated for removal in upcoming releases.")]
+        Task InitializeCollectionAsync(IConfiguration configuration, string collection);
+
         /// <summary>
         /// Generates a unique identifier for the store.
         /// </summary>
@@ -36,5 +49,13 @@ public interface IIdGenerator
         /// <param name="cancellationToken">The cancellation token.</param>
         /// <returns>A unique identifier</returns>
         Task<long> GetNextIdAsync(string collection, CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// Generates a unique identifier for the store.
+        /// </summary>
+        /// <param name="collection">The name of the collection to generate the identifier for.</param>
+        /// <returns>A unique identifier</returns>
+        [Obsolete($"Instead, utilize the {nameof(GetNextIdAsync)} method with a CancellationToken parameter. This current method is slated for removal in upcoming releases.")]
+        Task<long> GetNextIdAsync(string collection);
     }
 }
diff --git a/src/YesSql.Abstractions/IQuery.cs b/src/YesSql.Abstractions/IQuery.cs
index 5e1eac360..054f87cdc 100644
--- a/src/YesSql.Abstractions/IQuery.cs
+++ b/src/YesSql.Abstractions/IQuery.cs
@@ -88,21 +88,45 @@ public interface IQuery<T> where T : class
         /// </summary>
         Task<T> FirstOrDefaultAsync(CancellationToken cancellationToken = default);
 
+        /// <summary>
+        /// Executes the query and returns the first result matching the constraints.
+        /// </summary>
+        [Obsolete($"Instead, utilize the {nameof(FirstOrDefaultAsync)} method with a CancellationToken parameter. This current method is slated for removal in upcoming releases.")]
+        Task<T> FirstOrDefaultAsync();
+
         /// <summary>
         /// Executes the query and returns all documents matching the constraints.
         /// </summary>
         Task<IEnumerable<T>> ListAsync(CancellationToken cancellationToken = default);
 
+        /// <summary>
+        /// Executes the query and returns all documents matching the constraints.
+        /// </summary>
+        [Obsolete($"Instead, utilize the {nameof(ListAsync)} method with a CancellationToken parameter. This current method is slated for removal in upcoming releases.")]
+        Task<IEnumerable<T>> ListAsync();
+
         /// <summary>
         /// Executes the query and returns all documents matching the constraints.
         /// </summary>
         IAsyncEnumerable<T> ToAsyncEnumerable(CancellationToken cancellationToken = default);
 
+        /// <summary>
+        /// Executes the query and returns all documents matching the constraints.
+        /// </summary>
+        [Obsolete($"Instead, utilize the {nameof(ToAsyncEnumerable)} method with a CancellationToken parameter. This current method is slated for removal in upcoming releases.")]
+        IAsyncEnumerable<T> ToAsyncEnumerable();
+
         /// <summary>
         /// Executes a that returns the number of documents matching the constraints.
         /// </summary>
         Task<int> CountAsync(CancellationToken cancellationToken = default);
 
+        /// <summary>
+        /// Executes a that returns the number of documents matching the constraints.
+        /// </summary>
+        [Obsolete($"Instead, utilize the {nameof(CountAsync)} method with a CancellationToken parameter. This current method is slated for removal in upcoming releases.")]
+        Task<int> CountAsync();
+
         /// <summary>
         /// Returns the SQL alias currently used for the specified index type.
         /// </summary>
@@ -187,21 +211,46 @@ public interface IQueryIndex<T> where T : IIndex
         /// </summary>
         Task<T> FirstOrDefaultAsync(CancellationToken cancellationToken = default);
 
+        /// <summary>
+        /// Returns the first result only, if it exists.
+        /// </summary>
+        [Obsolete($"Instead, utilize the {nameof(FirstOrDefaultAsync)} method with a CancellationToken parameter. This current method is slated for removal in upcoming releases.")]
+        Task<T> FirstOrDefaultAsync();
+
         /// <summary>
         /// Executes the query.
         /// </summary>
         Task<IEnumerable<T>> ListAsync(CancellationToken cancellationToken = default);
 
+        /// <summary>
+        /// Executes the query.
+        /// </summary>
+        [Obsolete($"Instead, utilize the {nameof(ListAsync)} method with a CancellationToken parameter. This current method is slated for removal in upcoming releases.")]
+        Task<IEnumerable<T>> ListAsync();
+
         /// <summary>
         /// Executes the query for asynchronous iteration.
         /// </summary>
         /// <returns></returns>
         IAsyncEnumerable<T> ToAsyncEnumerable(CancellationToken cancellationToken = default);
 
+        /// <summary>
+        /// Executes the query for asynchronous iteration.
+        /// </summary>
+        /// <returns></returns>
+        [Obsolete($"Instead, utilize the {nameof(ToAsyncEnumerable)} method with a CancellationToken parameter. This current method is slated for removal in upcoming releases.")]
+        IAsyncEnumerable<T> ToAsyncEnumerable();
+
         /// <summary>
         /// Returns the number of results only.
         /// </summary>
         Task<int> CountAsync(CancellationToken cancellationToken = default);
+
+        /// <summary>
+        /// Returns the number of results only.
+        /// </summary>
+        [Obsolete($"Instead, utilize the {nameof(CountAsync)} method with a CancellationToken parameter. This current method is slated for removal in upcoming releases.")]
+        Task<int> CountAsync();
     }
 
     /// <summary>
diff --git a/src/YesSql.Abstractions/ISession.cs b/src/YesSql.Abstractions/ISession.cs
index e1e4fa97d..27b91aebd 100644
--- a/src/YesSql.Abstractions/ISession.cs
+++ b/src/YesSql.Abstractions/ISession.cs
@@ -34,6 +34,33 @@ public interface ISession : IDisposable, IAsyncDisposable
         /// <param name="cancellationToken">The cancellation token.</param>
         Task SaveAsync(object obj, bool checkConcurrency = false, string collection = null, CancellationToken cancellationToken = default);
 
+        /// <summary>
+        /// Saves a new or existing object to the store, and updates
+        /// the corresponding indexes.
+        /// </summary>
+        /// <param name="obj">The entity to save.</param>
+        /// <param name="checkConcurrency">If true, a <see cref="ConcurrencyException"/> is thrown if the entity has been updated concurrently by another session.</param>
+        /// <param name="collection">The name of the collection to store the object in.</param>
+        [Obsolete($"Instead, utilize the {nameof(SaveAsync)} method with a CancellationToken parameter. This current method is slated for removal in upcoming releases.")]
+        Task SaveAsync(object obj, bool checkConcurrency, string collection);
+
+        /// <summary>
+        /// Saves a new or existing object to the store, and updates
+        /// the corresponding indexes.
+        /// </summary>
+        /// <param name="obj">The entity to save.</param>
+        /// <param name="checkConcurrency">If true, a <see cref="ConcurrencyException"/> is thrown if the entity has been updated concurrently by another session.</param>
+        [Obsolete($"Instead, utilize the {nameof(SaveAsync)} method with a CancellationToken parameter. This current method is slated for removal in upcoming releases.")]
+        Task SaveAsync(object obj, bool checkConcurrency);
+
+        /// <summary>
+        /// Saves a new or existing object to the store, and updates
+        /// the corresponding indexes.
+        /// </summary>
+        /// <param name="obj">The entity to save.</param>
+        [Obsolete($"Instead, utilize the {nameof(SaveAsync)} method with a CancellationToken parameter. This current method is slated for removal in upcoming releases.")]
+        Task SaveAsync(object obj);
+
         /// <summary>
         /// Deletes an object and its indexes from the store.
         /// </summary>
@@ -84,6 +111,20 @@ public interface ISession : IDisposable, IAsyncDisposable
         /// <returns>A collection of objects in the same order they were defined.</returns>
         Task<IEnumerable<T>> GetAsync<T>(long[] ids, string collection = null, CancellationToken cancellationToken = default) where T : class;
 
+        /// <summary>
+        /// Loads objects by id.
+        /// </summary>
+        /// <returns>A collection of objects in the same order they were defined.</returns>
+        [Obsolete($"Instead, utilize the {nameof(GetAsync)} method with a CancellationToken parameter. This current method is slated for removal in upcoming releases.")]
+        Task<IEnumerable<T>> GetAsync<T>(long[] ids, string collection) where T : class;
+
+        /// <summary>
+        /// Loads objects by id.
+        /// </summary>
+        /// <returns>A collection of objects in the same order they were defined.</returns>
+        [Obsolete($"Instead, utilize the {nameof(GetAsync)} method with a CancellationToken parameter. This current method is slated for removal in upcoming releases.")]
+        Task<IEnumerable<T>> GetAsync<T>(long[] ids) where T : class;
+
         /// <summary>
         /// Creates a new <see cref="IQuery"/> object.
         /// </summary>
@@ -100,7 +141,7 @@ public interface ISession : IDisposable, IAsyncDisposable
         IQuery<T> ExecuteQuery<T>(ICompiledQuery<T> compiledQuery, string collection = null) where T : class;
 
         /// <summary>
-        /// Marks the current session as "canceled" such that any following calls to <see cref="SaveChangesAsync"/> will be ignored.
+        /// Marks the current session as "canceled" such that any following calls to <see cref="SaveChangesAsync(CancellationToken)"/> will be ignored.
         /// This is useful when multiple components can add operations to the session and one of them fails, making the session invalid.
         /// To instead rollback the transaction and revert any pending changes, use <see cref="ResetAsync"/>.
         /// </summary>
@@ -115,35 +156,73 @@ public interface ISession : IDisposable, IAsyncDisposable
         /// Flushes pending commands to the database.
         /// </summary>
         /// <remarks>
-        /// This doesn't commit or dispose of the transaction. A call to <see cref="SaveChangesAsync"/>
+        /// This doesn't commit or dispose of the transaction. A call to <see cref="SaveChangesAsync(CancellationToken)"/>
         /// is still necessary for the changes to be visible from other transactions.
         /// </remarks>
         Task FlushAsync(CancellationToken cancellationToken = default);
 
+        /// <summary>
+        /// Flushes pending commands to the database.
+        /// </summary>
+        /// <remarks>
+        /// This doesn't commit or dispose of the transaction. A call to <see cref="SaveChangesAsync(CancellationToken)"/>
+        /// is still necessary for the changes to be visible from other transactions.
+        /// </remarks>
+        [Obsolete($"Instead, utilize the {nameof(FlushAsync)} method with a CancellationToken parameter. This current method is slated for removal in upcoming releases.")]
+        Task FlushAsync();
+
         /// <summary>
         /// Flushes any changes, commits the transaction, and disposes the transaction.
         /// </summary>
         /// <remarks>
-        /// Sessions are not automatically committed when disposed, and <see cref="SaveChangesAsync"/>
+        /// Sessions are not automatically committed when disposed, and <see cref="SaveChangesAsync(CancellationToken)"/>
         /// must be called before disposing the <see cref="ISession"/>
         /// </remarks>
         Task SaveChangesAsync(CancellationToken cancellationToken = default);
 
+        /// <summary>
+        /// Flushes any changes, commits the transaction, and disposes the transaction.
+        /// </summary>
+        /// <remarks>
+        /// Sessions are not automatically committed when disposed, and <see cref="SaveChangesAsync(CancellationToken)"/>
+        /// must be called before disposing the <see cref="ISession"/>
+        /// </remarks>
+        [Obsolete($"Instead, utilize the {nameof(SaveChangesAsync)} method with a CancellationToken parameter. This current method is slated for removal in upcoming releases.")]
+        Task SaveChangesAsync();
+
         /// <summary>
         /// Creates or returns a <see cref="DbConnection"/>.
         /// </summary>
         Task<DbConnection> CreateConnectionAsync(CancellationToken cancellationToken = default);
 
+        /// <summary>
+        /// Creates or returns a <see cref="DbConnection"/>.
+        /// </summary>
+        [Obsolete($"Instead, utilize the {nameof(CreateConnectionAsync)} method with a CancellationToken parameter. This current method is slated for removal in upcoming releases.")]
+        Task<DbConnection> CreateConnectionAsync();
+
         /// <summary>
         /// Creates or returns an existing <see cref="DbTransaction"/> with the default isolation level.
         /// </summary>
         Task<DbTransaction> BeginTransactionAsync(CancellationToken cancellationToken = default);
 
+        /// <summary>
+        /// Creates or returns an existing <see cref="DbTransaction"/> with the default isolation level.
+        /// </summary>
+        [Obsolete($"Instead, utilize the {nameof(BeginTransactionAsync)} method with a CancellationToken parameter. This current method is slated for removal in upcoming releases.")]
+        Task<DbTransaction> BeginTransactionAsync();
+
         /// <summary>
         /// Creates or returns an existing <see cref="DbTransaction"/> with the specified isolation level.
         /// </summary>
         Task<DbTransaction> BeginTransactionAsync(IsolationLevel isolationLevel, CancellationToken cancellationToken = default);
 
+        /// <summary>
+        /// Creates or returns an existing <see cref="DbTransaction"/> with the specified isolation level.
+        /// </summary>
+        [Obsolete($"Instead, utilize the {nameof(BeginTransactionAsync)} method with a CancellationToken parameter. This current method is slated for removal in upcoming releases.")]
+        Task<DbTransaction> BeginTransactionAsync(IsolationLevel isolationLevel);
+
         /// <summary>
         /// Returns the current <see cref="DbTransaction"/> if it exists.
         /// </summary>
diff --git a/src/YesSql.Abstractions/IStore.cs b/src/YesSql.Abstractions/IStore.cs
index fda78c2f5..d89565df5 100644
--- a/src/YesSql.Abstractions/IStore.cs
+++ b/src/YesSql.Abstractions/IStore.cs
@@ -31,11 +31,23 @@ public interface IStore : IDisposable
         /// </summary>
         Task InitializeAsync(CancellationToken cancellationToken = default);
 
+        /// <summary>
+        /// Initializes the database by creating the required tables and the default collection if necessary.
+        /// </summary>
+        [Obsolete($"Instead, utilize the {nameof(InitializeAsync)} method with a CancellationToken parameter. This current method is slated for removal in upcoming releases.")]
+        Task InitializeAsync();
+
         /// <summary>
         /// Initializes a collection in the database by creating the required tables if necessary.
         /// </summary>
         Task InitializeCollectionAsync(string collection, CancellationToken cancellationToken = default);
 
+        /// <summary>
+        /// Initializes a collection in the database by creating the required tables if necessary.
+        /// </summary>
+        [Obsolete($"Instead, utilize the {nameof(InitializeCollectionAsync)} method with a CancellationToken parameter. This current method is slated for removal in upcoming releases.")]
+        Task InitializeCollectionAsync(string collection);
+
         /// <summary>
         /// Create an instance of <see cref="IEnumerable&lt;IndexDescriptor&gt;" /> containing descriptors for all indexes associated to a type and a collection.
         /// </summary>        
diff --git a/src/YesSql.Core/Services/DbBlockIdGenerator.cs b/src/YesSql.Core/Services/DbBlockIdGenerator.cs
index c90cd3cf5..19c085e6d 100644
--- a/src/YesSql.Core/Services/DbBlockIdGenerator.cs
+++ b/src/YesSql.Core/Services/DbBlockIdGenerator.cs
@@ -74,6 +74,9 @@ await localBuilder.CreateTableAsync(TableName, table => table
             }
         }
 
+        public Task InitializeAsync(IStore store)
+            => InitializeAsync(store, CancellationToken.None);
+
         public long GetNextId(string collection)
             => GetNextIdAsync(collection).GetAwaiter().GetResult();
 
@@ -106,6 +109,9 @@ public async Task<long> GetNextIdAsync(string collection, CancellationToken canc
             }
         }
 
+        public Task<long> GetNextIdAsync(string collection)
+            => GetNextIdAsync(collection, CancellationToken.None);
+
         private async Task LeaseRangeAsync(Range range, CancellationToken cancellationToken )
         {
             var affectedRows = 0;
@@ -261,6 +267,9 @@ public async Task InitializeCollectionAsync(IConfiguration configuration, string
             _ranges[collection] = new Range(collection);
         }
 
+        public Task InitializeCollectionAsync(IConfiguration configuration, string collection)
+            => InitializeCollectionAsync(configuration, collection, CancellationToken.None);
+
         private sealed class Range
         {
             public Range(string collection)
diff --git a/src/YesSql.Core/Services/DefaultIdGenerator.cs b/src/YesSql.Core/Services/DefaultIdGenerator.cs
index a6fb71b4b..c39e6d689 100644
--- a/src/YesSql.Core/Services/DefaultIdGenerator.cs
+++ b/src/YesSql.Core/Services/DefaultIdGenerator.cs
@@ -46,6 +46,9 @@ public Task InitializeAsync(IStore store, CancellationToken cancellationToken =
             return Task.CompletedTask;
         }
 
+        public Task InitializeAsync(IStore store)
+            => InitializeAsync(store, CancellationToken.None);
+
         public async Task InitializeCollectionAsync(IConfiguration configuration, string collection, CancellationToken cancellationToken = default)
         {
             // Extract the current max value from the database
@@ -72,5 +75,11 @@ public async Task InitializeCollectionAsync(IConfiguration configuration, string
 
             _seeds[collection] = result == DBNull.Value ? 0 : Convert.ToInt64(result);
         }
+
+        public Task InitializeCollectionAsync(IConfiguration configuration, string collection)
+            => InitializeCollectionAsync(configuration, collection, CancellationToken.None);
+
+        public Task<long> GetNextIdAsync(string collection)
+            => GetNextIdAsync(collection, CancellationToken.None);
     }
 }
diff --git a/src/YesSql.Core/Services/DefaultQuery.cs b/src/YesSql.Core/Services/DefaultQuery.cs
index 8c9816e28..9247ab35c 100644
--- a/src/YesSql.Core/Services/DefaultQuery.cs
+++ b/src/YesSql.Core/Services/DefaultQuery.cs
@@ -1170,6 +1170,9 @@ public async Task<int> CountAsync(CancellationToken cancellationToken = default)
             }
         }
 
+        public Task<int> CountAsync()
+            => CountAsync(CancellationToken.None);
+
         IQuery<T> IQuery.For<T>(bool filterType)
         {
             _queryState.GetBindings().Clear();
@@ -1308,11 +1311,17 @@ protected async Task<T> FirstOrDefaultImpl(CancellationToken cancellationToken =
                 }
             }
 
+            public Task<T> FirstOrDefaultAsync()
+                => FirstOrDefaultAsync(CancellationToken.None);
+
             Task<IEnumerable<T>> IQuery<T>.ListAsync(CancellationToken cancellationToken)
             {
                 return ListImpl(cancellationToken);
             }
 
+            Task<IEnumerable<T>> IQuery<T>.ListAsync()
+                => ((IQuery<T>)this).ListAsync(CancellationToken.None);
+
 #pragma warning disable CS8425 // Async-iterator member has one or more parameters of type 'CancellationToken' but none of them is decorated with the 'EnumeratorCancellation' attribute, so the cancellation token parameter from the generated 'IAsyncEnumerable<>.GetAsyncEnumerator' will be unconsumed
             async IAsyncEnumerable<T> IQuery<T>.ToAsyncEnumerable(CancellationToken cancellationToken)
 #pragma warning restore CS8425 // Async-iterator member has one or more parameters of type 'CancellationToken' but none of them is decorated with the 'EnumeratorCancellation' attribute, so the cancellation token parameter from the generated 'IAsyncEnumerable<>.GetAsyncEnumerator' will be unconsumed
@@ -1324,6 +1333,9 @@ async IAsyncEnumerable<T> IQuery<T>.ToAsyncEnumerable(CancellationToken cancella
                 }
             }
 
+            IAsyncEnumerable<T> IQuery<T>.ToAsyncEnumerable()
+                => ((IQuery<T>)this).ToAsyncEnumerable(CancellationToken.None);
+
             internal async Task<IEnumerable<T>> ListImpl(CancellationToken cancellationToken)
             {
                 // TODO: [IAsyncEnumerable] Once Dapper supports IAsyncEnumerable we can return it by default, and buffer it in ListAsync instead
@@ -1494,6 +1506,9 @@ Task<int> IQuery<T>.CountAsync(CancellationToken cancellationToken)
                 return _query.CountAsync(cancellationToken);
             }
 
+            Task<int> IQuery<T>.CountAsync()
+                => ((IQuery<T>)this).CountAsync(CancellationToken.None);
+
             IQuery<T> IQuery<T>.Any(params Func<IQuery<T>, IQuery<T>>[] predicates)
             {
                 // Scope the currentPredicate so multiple calls will not act on the new predicate.
@@ -1620,11 +1635,17 @@ Task<T> IQueryIndex<T>.FirstOrDefaultAsync(CancellationToken cancellationToken)
                 return FirstOrDefaultImpl(cancellationToken);
             }
 
+            Task<T> IQueryIndex<T>.FirstOrDefaultAsync()
+                => ((IQueryIndex<T>)this).FirstOrDefaultAsync(CancellationToken.None);
+
             Task<IEnumerable<T>> IQueryIndex<T>.ListAsync(CancellationToken cancellationToken)
             {
                 return ListImpl(cancellationToken);
             }
 
+            Task<IEnumerable<T>> IQueryIndex<T>.ListAsync()
+                => ((IQueryIndex<T>)this).ListAsync(CancellationToken.None);
+
 #pragma warning disable CS8425 // Async-iterator member has one or more parameters of type 'CancellationToken' but none of them is decorated with the 'EnumeratorCancellation' attribute, so the cancellation token parameter from the generated 'IAsyncEnumerable<>.GetAsyncEnumerator' will be unconsumed
             async IAsyncEnumerable<T> IQueryIndex<T>.ToAsyncEnumerable(CancellationToken cancellationToken)
 #pragma warning restore CS8425 // Async-iterator member has one or more parameters of type 'CancellationToken' but none of them is decorated with the 'EnumeratorCancellation' attribute, so the cancellation token parameter from the generated 'IAsyncEnumerable<>.GetAsyncEnumerator' will be unconsumed
@@ -1636,6 +1657,9 @@ async IAsyncEnumerable<T> IQueryIndex<T>.ToAsyncEnumerable(CancellationToken can
                 }
             }
 
+            IAsyncEnumerable<T> IQueryIndex<T>.ToAsyncEnumerable()
+                => ((IQueryIndex<T>)this).ToAsyncEnumerable(CancellationToken.None);
+
             IQueryIndex<T> IQueryIndex<T>.Skip(int count)
             {
                 if (count > 0)
@@ -1669,6 +1693,9 @@ async Task<int> IQueryIndex<T>.CountAsync(CancellationToken cancellationToken)
                 return await _query.CountAsync(cancellationToken);
             }
 
+            Task<int> IQueryIndex<T>.CountAsync()
+                => ((IQueryIndex<T>)this).CountAsync(CancellationToken.None);
+
             IQueryIndex<TIndex> IQueryIndex<T>.With<TIndex>()
             {
                 _query.Bind<TIndex>();
diff --git a/src/YesSql.Core/Session.cs b/src/YesSql.Core/Session.cs
index 898ca29b3..2f61b3ca4 100644
--- a/src/YesSql.Core/Session.cs
+++ b/src/YesSql.Core/Session.cs
@@ -160,6 +160,15 @@ public async Task SaveAsync(object entity, bool checkConcurrency = false, string
             state.Saved.Add(entity);
         }
 
+        public Task SaveAsync(object entity, bool checkConcurrency, string collection)
+            => SaveAsync(entity, checkConcurrency, collection, CancellationToken.None);
+
+        public Task SaveAsync(object entity, bool checkConcurrency)
+            => SaveAsync(entity, checkConcurrency, null, CancellationToken.None);
+
+        public Task SaveAsync(object entity)
+            => SaveAsync(entity, false, null, CancellationToken.None);
+
         public bool Import(object entity, long id = 0, long version = 0, string collection = null)
         {
             CheckDisposed();
@@ -616,6 +625,12 @@ public IEnumerable<T> Get<T>(IList<Document> documents, string collection) where
             return result;
         }
 
+        public Task<IEnumerable<T>> GetAsync<T>(long[] ids, string collection) where T : class
+            => GetAsync<T>(ids, collection, CancellationToken.None);
+
+        public Task<IEnumerable<T>> GetAsync<T>(long[] ids) where T : class
+            => GetAsync<T>(ids, null, CancellationToken.None);
+
         public IQuery Query(string collection = null)
         {
             return new DefaultQuery(this, _tablePrefix, collection);
@@ -690,6 +705,9 @@ public Task FlushAsync(CancellationToken cancellationToken = default)
             return FlushInternalAsync(false, cancellationToken);
         }
 
+        public Task FlushAsync()
+            => FlushAsync(CancellationToken.None);
+
         private async Task FlushInternalAsync(bool saving, CancellationToken cancellationToken)
         {
             if (!HasWork())
@@ -943,6 +961,9 @@ public async Task SaveChangesAsync(CancellationToken cancellationToken = default
             }
         }
 
+        public Task SaveChangesAsync()
+            => SaveChangesAsync(CancellationToken.None);
+
         public async ValueTask DisposeAsync()
         {
             // Do nothing if Dispose() was already called
@@ -1407,11 +1428,17 @@ public async Task<DbConnection> CreateConnectionAsync(CancellationToken cancella
             return _connection;
         }
 
+        public Task<DbConnection> CreateConnectionAsync()
+            => CreateConnectionAsync(CancellationToken.None);
+
         public DbTransaction CurrentTransaction => _transaction;
 
         public Task<DbTransaction> BeginTransactionAsync(CancellationToken cancellationToken = default)
             => BeginTransactionAsync(Store.Configuration.IsolationLevel, cancellationToken);
 
+        public Task<DbTransaction> BeginTransactionAsync()
+            => BeginTransactionAsync(CancellationToken.None);
+
         /// <summary>
         /// Begins a new transaction if none has been yet. Use this method when writes need to be done.
         /// </summary>
@@ -1431,6 +1458,9 @@ public async Task<DbTransaction> BeginTransactionAsync(IsolationLevel isolationL
             return _transaction;
         }
 
+        public Task<DbTransaction> BeginTransactionAsync(IsolationLevel isolationLevel)
+            => BeginTransactionAsync(isolationLevel, CancellationToken.None);
+
         public Task CancelAsync()
         {
             EnterAsyncExecution();
diff --git a/src/YesSql.Core/Store.cs b/src/YesSql.Core/Store.cs
index 6216fd854..7183b348d 100644
--- a/src/YesSql.Core/Store.cs
+++ b/src/YesSql.Core/Store.cs
@@ -115,6 +115,9 @@ public async Task InitializeAsync(CancellationToken cancellationToken = default)
             await InitializeCollectionAsync(string.Empty, cancellationToken);
         }
 
+        public Task InitializeAsync()
+            => InitializeAsync(CancellationToken.None);
+
         public async Task InitializeCollectionAsync(string collection, CancellationToken cancellationToken = default)
         {
             var documentTable = Configuration.TableNameConvention.GetDocumentTable(collection);
@@ -199,6 +202,9 @@ await builder.AlterTableAsync(documentTable, table => table
             }
         }
 
+        public Task InitializeCollectionAsync(string collection)
+            => InitializeCollectionAsync(collection, CancellationToken.None);
+
         private void ValidateConfiguration()
         {
             if (Configuration.ConnectionFactory == null)