@deterministic-code/datasources 0.0.0-stage → 0.1.1

package/dist/index.d.ts

@@ -0,0 +1,119 @@
+export type { ICommand } from "./ICommand.js";
+export { execute, executeReader } from "./ICommand.js";
+export type { ICommandMiddleware } from "./ICommandMiddleware.js";
+export type { IConnection } from "./IConnection.js";
+export type { IDatasource } from "./IDatasource.js";
+export type { IDriver } from "./IDriver.js";
+export { columnType } from "./IDriver.js";
+export type { Information } from "./Information.js";
+export type { DatasourceOptions } from "./DatasourceOptions.js";
+export { DatasourceFactory } from "./DatasourceFactory.js";
+export { ProviderCatalog } from "./ProviderCatalog.js";
+export type { ICreateTableStatement, ICreateIndexStatement, IDeleteStatement, IExpression, IBulkDeleteStatement, IBulkInsertStatement, IBulkUpdateStatement, IInsertStatement, ISelectStatement, IStatement, IStatementVisitor, ICondition, IConditionVisitor, IExecuteStoredProcedureStatement, IReturnStatement, ITableConstraint, TableConstraintKind, IUpdateStatement, IWhere, } from "./statements/index.js";
+export type { IReader } from "./IReader.js";
+export type { IRepository } from "./IRepository.js";
+export type { IReadonlyRepository } from "./IReadonlyRepository.js";
+export type { ICRUDRepository } from "./ICRUDRepository.js";
+export { ReadonlyRepository, untyped } from "./ReadonlyRepository.js";
+export type { IRepositoryFactory } from "./IRepositoryFactory.js";
+export type { ICRUDRepositoryFactory } from "./ICRUDRepositoryFactory.js";
+export { RepositoryFactory } from "./RepositoryFactory.js";
+export { RepositoryAccess } from "./RepositoryAccess.js";
+export { RepositoryNotRegisteredError } from "./RepositoryNotRegisteredError.js";
+export type { IEnriched } from "./IEnriched.js";
+export type { IRepositoryTree } from "./IRepositoryTree.js";
+export type { IRepositoryTreeNode } from "./IRepositoryTreeNode.js";
+export type { Association, Enrichment } from "./Enrichment.js";
+export { EnrichmentPropertyType } from "./EnrichmentPropertyType.js";
+export type { IReadonlyEnrichmentStrategy } from "./IReadonlyEnrichmentStrategy.js";
+export type { IWriteEnrichmentStrategy } from "./IWriteEnrichmentStrategy.js";
+export type { WriteMode } from "./WriteMode.js";
+export { DefaultReadonlyEnrichmentStrategy } from "./DefaultReadonlyEnrichmentStrategy.js";
+export { DefaultWriteEnrichmentStrategy } from "./DefaultWriteEnrichmentStrategy.js";
+export { DeleteEnrichmentStrategy } from "./DeleteEnrichmentStrategy.js";
+export { CascadeDeleteEnrichmentStrategy } from "./CascadeDeleteEnrichmentStrategy.js";
+export { UpdateEnrichmentStrategy } from "./UpdateEnrichmentStrategy.js";
+export { DefaultUpdateEnrichmentStrategy } from "./DefaultUpdateEnrichmentStrategy.js";
+export { CreateEnrichmentStrategy } from "./CreateEnrichmentStrategy.js";
+export { DefaultCreateEnrichmentStrategy } from "./DefaultCreateEnrichmentStrategy.js";
+export { CascadeDeleteUpdateEnrichmentStrategy } from "./CascadeDeleteUpdateEnrichmentStrategy.js";
+export { LazyWriteEnrichmentStrategy } from "./LazyWriteEnrichmentStrategy.js";
+export { HashsetOptimizedReadonlyEnrichmentStrategy } from "./HashsetOptimizedReadonlyEnrichmentStrategy.js";
+export { NestedToObjectEnrichmentStrategy } from "./NestedToObjectEnrichmentStrategy.js";
+export { BulkCRUDRepository } from "./BulkCRUDRepository.js";
+export type { IBulkWriteStrategy } from "./IBulkWriteStrategy.js";
+export type { BulkCommand } from "./BulkCommand.js";
+export { SingleCommandIBulkWriteStrategy } from "./SingleCommandIBulkWriteStrategy.js";
+export { BatchCommandIBulkWriteStrategy } from "./BatchCommandIBulkWriteStrategy.js";
+export { StoredProcedureBulkWriteStrategy } from "./StoredProcedureBulkWriteStrategy.js";
+export { RepositoryTree } from "./RepositoryTree.js";
+export { RepositoryTreeNode } from "./RepositoryTreeNode.js";
+export { CRUDRepository } from "./CRUDRepository.js";
+export { ReadonlyRepositoryBuilder } from "./ReadonlyRepositoryBuilder.js";
+export { CRUDRepositoryBuilder } from "./CRUDRepositoryBuilder.js";
+export { StatementMappers } from "./StatementMappers.js";
+export { ReadonlyRepositoryStatements } from "./ReadonlyRepositoryStatements.js";
+export { CRUDRepositoryStatements } from "./CRUDRepositoryStatements.js";
+export type { BuiltRepository } from "./BuiltRepository.js";
+export { createCRUDRepositoryOptions } from "./createCRUDRepositoryOptions.js";
+export { createReadonlyRepositoryMappingOptions } from "./createReadonlyRepositoryMappingOptions.js";
+export type { ReadonlyRepositoryMappingOptions } from "./ReadonlyRepositoryMappingOptions.js";
+export type { CRUDRepositoryOptions } from "./CRUDRepositoryOptions.js";
+export { Response } from "./Response.js";
+export type { ITransaction } from "./ITransaction.js";
+export type { IUnitOfWork } from "./IUnitOfWork.js";
+export { UnitOfWorkTransaction } from "./UnitOfWorkTransaction.js";
+export { IsolationLevel } from "./IsolationLevel.js";
+export type { IsolationLevel as IsolationLevelName } from "./IsolationLevel.js";
+export type { Comparison } from "./statements/index.js";
+export { ArrayExpression, CheckConstraint, ColumnDefault, Condition, ConditionRenderer, ExpressionRenderer, CreateIndexStatement, CreateTableStatement, CreateTableStatementTextRenderer, CreateIndexStatementTextRenderer, SelectStatementTextRenderer, InsertStatementTextRenderer, UpdateStatementTextRenderer, DeleteStatementTextRenderer, BulkInsertStatementTextRenderer, BulkUpdateStatementTextRenderer, BulkDeleteStatementTextRenderer, ExecuteStoredProcedureStatementTextRenderer, ReturnStatementTextRenderer, SelectInsertedIdStatementTextRenderer, DefaultStatementTextRenderer, DeleteStatement, ForeignKey, Identifier, InsertStatement, BulkInsertStatement, BulkUpdateStatement, BulkDeleteStatement, Literal, NotNull, Operator, eq, ne, gt, lt, ge, le, PrimaryKey, Aggregate, OrderBy, SelectStatement, StatementParser, StatementRenderer, StatementTextRenderer, Native, n, Subquery, ReferentialAction, ExpressionEvaluator, StatementEvaluator, ExecuteStoredProcedureStatement, SelectInsertedIdStatement, ReturnStatement, UniqueConstraint, UpdateStatement, WhereText, Where, Join, } from "./statements/index.js";
+export type { IDatasourceFactory } from "./IDatasourceFactory.js";
+export type { Parameter } from "./Parameter.js";
+export { ParameterDirection } from "./ParameterDirection.js";
+export type { ParameterDirection as ParameterDirectionName } from "./ParameterDirection.js";
+export type { Row } from "./Row.js";
+export { ArrayReader } from "./ArrayReader.js";
+export { FirstResultReader } from "./FirstResultReader.js";
+export { StreamingReader, statementReader } from "./StreamingReader.js";
+export { splitStatements } from "./splitStatements.js";
+export { statementParameters } from "./statementParameters.js";
+export { statementUsesParameter } from "./statementUsesParameter.js";
+export { collectAsync } from "./collectAsync.js";
+export { CommandMiddlewareHost } from "./CommandMiddlewareHost.js";
+export { ConsoleCommandMiddleware, formatElapsed, } from "./ConsoleCommandMiddleware.js";
+export { ExpectConsoleMiddleware } from "./ExpectConsoleMiddleware.js";
+export { Datasource } from "./Datasource.js";
+export { DatasourceUrl } from "./DatasourceUrl.js";
+export { DatasourceUrlParser } from "./DatasourceUrlParser.js";
+export { DatasourceError } from "./DatasourceError.js";
+export type { Cell, Cells } from "./converters/Cell.js";
+export type { Constructable } from "./converters/Constructable.js";
+export { TypeConverter } from "./converters/TypeConverter.js";
+export { MetaDataRowTypeConverter } from "./converters/MetaDataRowTypeConverter.js";
+export { RowTypeConverter } from "./converters/RowTypeConverter.js";
+export { ToLowerCaseConverter } from "./converters/ToLowerCaseConverter.js";
+export { ToUpperCaseConverter } from "./converters/ToUpperCaseConverter.js";
+export { ChangeCasingConverter, type Casing } from "./converters/ChangeCasingConverter.js";
+export { PluralizerConverter } from "./converters/PluralizerConverter.js";
+export { RegexConverter } from "./converters/RegexConverter.js";
+export { ReplaceConverter } from "./converters/ReplaceConverter.js";
+export type { IMapper } from "./mappers/IMapper.js";
+export type { IFlatToNestedMapper } from "./mappers/IFlatToNestedMapper.js";
+export type { TypeMap, TypeMapFields } from "./mappers/TypeMap.js";
+export type { TypeMapGroup } from "./mappers/TypeMapGroup.js";
+export { FlatToNestedMapper } from "./mappers/FlatToNestedMapper.js";
+export { ChangeCasingMapper } from "./mappers/ChangeCasingMapper.js";
+export { DictionaryMapper } from "./mappers/DictionaryMapper.js";
+export { IdentityMapper } from "./mappers/IdentityMapper.js";
+export { PluralizerMapper } from "./mappers/PluralizerMapper.js";
+export { TransformMapper } from "./mappers/TransformMapper.js";
+export { TransformConverterMapper } from "./mappers/TransformConverterMapper.js";
+export { RowTypeMapper } from "./mappers/RowTypeMapper.js";
+export { parametersToRecord } from "./parametersToRecord.js";
+export { ProviderNotImplementedError } from "./ProviderNotImplementedError.js";
+export { ProviderNotInstalledError } from "./ProviderNotInstalledError.js";
+export type { Column, JoinKind, SelectStatementOptions, ReferentialAction as ReferentialActionName, SortDirection } from "./statements/index.js";
+export type { Field, Scalar } from "./builders/index.js";
+export { readerToAsyncIterable } from "./readerToAsyncIterable.js";
+export { StubCommand, StubConnection, StubDatasource, StubReader, StubRepository, StubTransaction, createStubDatasource, } from "./stubs/index.js";
+export { MockCommand, MockConnection, MockDatasource, MockDriver, MockSelectStatement, MockReader, MockRepository, MockTransaction, MockWhere, } from "./mocks/index.js";

package/dist/mappers/ChangeCasingMapper.d.ts

@@ -0,0 +1,9 @@
+import { type Casing } from "../converters/ChangeCasingConverter.js";
+import type { IMapper } from "./IMapper.js";
+export declare class ChangeCasingMapper implements IMapper<string, string> {
+    private readonly forward;
+    private readonly reverse;
+    constructor(from: Casing, to: Casing);
+    map: (value: string) => string;
+    reverseMap: (value: string) => string;
+}

package/dist/mappers/DictionaryMapper.d.ts

@@ -0,0 +1,8 @@
+import type { IMapper } from "./IMapper.js";
+export declare class DictionaryMapper<T extends string | number> implements IMapper<T, T> {
+    private readonly forward;
+    private readonly reverse;
+    constructor(map: readonly (readonly [T, T])[]);
+    map: (value: T) => T;
+    reverseMap: (value: T) => T;
+}

package/dist/mappers/FlatToNestedMapper.d.ts

@@ -0,0 +1,20 @@
+import type { Cells } from "../converters/Cell.js";
+import type { IFlatToNestedMapper } from "./IFlatToNestedMapper.js";
+import type { TypeMap } from "./TypeMap.js";
+export declare class FlatToNestedMapper<T> implements IFlatToNestedMapper<T> {
+    readonly spec: TypeMap<T>;
+    private readonly scalars;
+    private readonly groups;
+    private readonly parentDest;
+    constructor(spec: TypeMap<T>);
+    map: (rows: Iterable<T | Cells>) => T[];
+    reverseMap: (values: T[]) => Cells[];
+    private _map;
+    private _collapse;
+    private explode;
+    private scalarsOf;
+    private withChild;
+    private mapped;
+    private mark;
+    private merge;
+}

package/dist/mappers/IFlatToNestedMapper.d.ts

@@ -0,0 +1,6 @@
+import type { Cells } from "../converters/Cell.js";
+import type { IMapper } from "./IMapper.js";
+import type { TypeMap } from "./TypeMap.js";
+export interface IFlatToNestedMapper<T> extends IMapper<Iterable<T | Cells>, T[]> {
+    readonly spec: TypeMap<T>;
+}

package/dist/mappers/IMapper.d.ts

@@ -0,0 +1,4 @@
+export interface IMapper<TFrom, TTo> {
+    map(value: TFrom): TTo;
+    reverseMap(value: TTo): TFrom;
+}

package/dist/mappers/IdentityMapper.d.ts

@@ -0,0 +1,5 @@
+import type { IMapper } from "./IMapper.js";
+export declare class IdentityMapper<T> implements IMapper<T, T> {
+    map: (value: T) => T;
+    reverseMap: (value: T) => T;
+}

package/dist/mappers/PluralizerMapper.d.ts

@@ -0,0 +1,6 @@
+import type { IMapper } from "./IMapper.js";
+export declare class PluralizerMapper implements IMapper<string, string> {
+    private readonly pluralizer;
+    map: (value: string) => string;
+    reverseMap: (value: string) => string;
+}

package/dist/mappers/RowTypeMapper.d.ts

@@ -0,0 +1,6 @@
+import type { Cells } from "../converters/Cell.js";
+import type { TypeConverter } from "../converters/TypeConverter.js";
+import { TransformMapper } from "./TransformMapper.js";
+export declare class RowTypeMapper<T> extends TransformMapper<Cells, T> {
+    constructor(converter?: TypeConverter<T, Cells>);
+}

package/dist/mappers/TransformConverterMapper.d.ts

@@ -0,0 +1,5 @@
+import type { TypeConverter } from "../converters/TypeConverter.js";
+import { TransformMapper } from "./TransformMapper.js";
+export declare class TransformConverterMapper<T> extends TransformMapper<T, T> {
+    constructor(converter: TypeConverter<T, T>, filter?: (value: T) => boolean);
+}

package/dist/mappers/TransformMapper.d.ts

@@ -0,0 +1,6 @@
+import type { IMapper } from "./IMapper.js";
+export declare class TransformMapper<TFrom, TTo> implements IMapper<TFrom, TTo> {
+    readonly map: (value: TFrom) => TTo;
+    readonly reverseMap: (value: TTo) => TFrom;
+    constructor(map: (value: TFrom) => TTo, reverseMap: (value: TTo) => TFrom);
+}

package/dist/mappers/TypeMap.d.ts

@@ -0,0 +1,8 @@
+import type { TypeMapGroup } from "./TypeMapGroup.js";
+export type TypeMapFields<T> = {
+    [K in keyof T]?: T[K] extends readonly (infer E)[] ? TypeMapGroup<E> : string;
+};
+export type TypeMap<T> = {
+    key: string;
+    fields: TypeMapFields<T>;
+};

package/dist/mappers/TypeMapGroup.d.ts

@@ -0,0 +1,5 @@
+import type { TypeMapFields } from "./TypeMap.js";
+export type TypeMapGroup<E> = {
+    key: string;
+    fields: TypeMapFields<E>;
+};

package/dist/mocks/index.d.ts

@@ -0,0 +1,9 @@
+export { MockCommand } from "./mock-command.js";
+export { MockConnection } from "./mock-connection.js";
+export { MockDatasource } from "./mock-datasource.js";
+export { MockDriver } from "./mock-driver.js";
+export { MockSelectStatement } from "./mock-select-statement.js";
+export { MockReader } from "./mock-reader.js";
+export { MockRepository } from "./mock-repository.js";
+export { MockTransaction } from "./mock-transaction.js";
+export { MockWhere } from "./mock-where.js";

package/dist/mocks/mock-command.d.ts

@@ -0,0 +1,28 @@
+import type { ICommand } from "../ICommand.js";
+import type { IConnection } from "../IConnection.js";
+import type { Cells } from "../converters/Cell.js";
+import type { IReader } from "../IReader.js";
+import type { Response } from "../Response.js";
+import { CommandMiddlewareHost } from "../CommandMiddlewareHost.js";
+import type { Parameter } from "../Parameter.js";
+import type { IStatement } from "../statements/IStatement.js";
+import { Native } from "../statements/Native.js";
+export declare class MockCommand extends CommandMiddlewareHost implements ICommand {
+    readonly connection: IConnection;
+    executeCalls: {
+        text: string;
+        parameters?: Parameter[];
+    }[];
+    executeReaderCalls: {
+        text: string;
+        parameters?: Parameter[];
+    }[];
+    executeError?: unknown;
+    executeReaderError?: unknown;
+    response: Response;
+    reader: IReader<Cells>;
+    constructor(connection: IConnection);
+    executeReaderStatement: (statement: IStatement, parameters?: Parameter[]) => Promise<IReader<Cells>>;
+    executeReaderNative(text: Native, parameters?: Parameter[]): Promise<IReader<Cells>>;
+    executeNative(text: Native, parameters?: Parameter[]): Promise<Response>;
+}

package/dist/mocks/mock-connection.d.ts

@@ -0,0 +1,22 @@
+import type { ICommand } from "../ICommand.js";
+import type { IConnection } from "../IConnection.js";
+import type { ITransaction } from "../ITransaction.js";
+import { type IsolationLevel as Isolation } from "../IsolationLevel.js";
+export declare class MockConnection implements IConnection {
+    readonly provider: string;
+    openCalls: number;
+    closeCalls: number;
+    startTransactionCalls: number;
+    openError?: unknown;
+    closeError?: unknown;
+    startTransactionError?: unknown;
+    transaction: ITransaction;
+    command?: ICommand;
+    isOpen: boolean;
+    constructor(transaction?: ITransaction, provider?: string);
+    createCommand: () => ICommand;
+    open(): Promise<void>;
+    close(): Promise<void>;
+    [Symbol.asyncDispose]: () => Promise<void>;
+    startTransaction(isolation?: Isolation): Promise<ITransaction>;
+}

package/dist/mocks/mock-datasource.d.ts

@@ -0,0 +1,24 @@
+import type { Constructable } from "../converters/Constructable.js";
+import type { ICommand } from "../ICommand.js";
+import type { IConnection } from "../IConnection.js";
+import type { IDatasource } from "../IDatasource.js";
+import type { IReadonlyRepository } from "../IReadonlyRepository.js";
+import type { ICRUDRepository } from "../ICRUDRepository.js";
+import { RepositoryFactory } from "../RepositoryFactory.js";
+export declare class MockDatasource implements IDatasource {
+    readonly provider: string;
+    createConnectionCalls: number;
+    createCommandCalls: Array<IConnection | undefined>;
+    createRepositoryCalls: Array<IConnection | undefined>;
+    connection: IConnection;
+    command?: ICommand;
+    repository?: ICRUDRepository;
+    readonly repositories: RepositoryFactory;
+    constructor(provider?: string);
+    createConnection(): Promise<IConnection>;
+    createCommand(connection?: IConnection): Promise<ICommand>;
+    createRepository<T>(type: Constructable<T>, connection?: IConnection): ICRUDRepository<T>;
+    createRepository(typeName: string, connection?: IConnection): ICRUDRepository;
+    createReadonlyRepository<T>(type: Constructable<T>, connection?: IConnection): IReadonlyRepository<T>;
+    createReadonlyRepository(typeName: string, connection?: IConnection): IReadonlyRepository;
+}

package/dist/mocks/mock-driver.d.ts

@@ -0,0 +1,15 @@
+import type { DatasourceOptions } from "../DatasourceOptions.js";
+import type { ICommand } from "../ICommand.js";
+import type { IConnection } from "../IConnection.js";
+import type { IDriver } from "../IDriver.js";
+import type { ITransaction } from "../ITransaction.js";
+import type { IsolationLevel } from "../IsolationLevel.js";
+import type { Cell } from "../converters/Cell.js";
+import type { TypeConverter } from "../converters/TypeConverter.js";
+export declare class MockDriver implements IDriver {
+    rowTypeConverters: Record<string, TypeConverter<Cell, Cell>>;
+    columnType: (name: string) => string;
+    connection: (_options?: DatasourceOptions) => IConnection;
+    command: (connection: IConnection) => ICommand;
+    transaction: (connection: IConnection, isolation?: IsolationLevel) => ITransaction;
+}

package/dist/mocks/mock-reader.d.ts

@@ -0,0 +1,14 @@
+import type { IReader } from "../IReader.js";
+export declare class MockReader<T = unknown> implements IReader<T> {
+    rows: readonly T[];
+    current: T | undefined;
+    nextCalls: number;
+    nextError?: unknown;
+    private index;
+    constructor(rows?: readonly T[]);
+    next(): Promise<boolean>;
+    read(): AsyncIterable<T>;
+    nextResult(): Promise<boolean>;
+    dispose(): Promise<void>;
+    [Symbol.asyncDispose]: () => Promise<void>;
+}

package/dist/mocks/mock-repository.d.ts

@@ -0,0 +1,42 @@
+import type { Scalar } from "../builders/Scalar.js";
+import type { Cells } from "../converters/Cell.js";
+import type { Constructable } from "../converters/Constructable.js";
+import type { IConnection } from "../IConnection.js";
+import type { Parameter } from "../Parameter.js";
+import type { IExecuteStoredProcedureStatement } from "../statements/IExecuteStoredProcedureStatement.js";
+import type { ISelectStatement } from "../statements/ISelectStatement.js";
+import type { ICRUDRepository } from "../ICRUDRepository.js";
+import { ReadonlyRepository } from "../ReadonlyRepository.js";
+import type { ReadonlyRepositoryMappingOptions } from "../ReadonlyRepositoryMappingOptions.js";
+import type { Response } from "../Response.js";
+import type { IWhere } from "../statements/IWhere.js";
+export declare class MockRepository<T = unknown> extends ReadonlyRepository<T> implements ICRUDRepository<T> {
+    readonly ids: readonly string[];
+    items: T[];
+    readSingleCalls: Array<ISelectStatement | IWhere | IExecuteStoredProcedureStatement | undefined>;
+    readCalls: Array<ISelectStatement | IWhere | IExecuteStoredProcedureStatement | undefined>;
+    addCalls: T[];
+    updateCalls: Array<{
+        item: T;
+        byWhere?: IWhere;
+    }>;
+    deleteCalls: Array<{
+        item: T;
+        byWhere?: IWhere;
+    }>;
+    readSingleError?: unknown;
+    readError?: unknown;
+    addError?: unknown;
+    updateError?: unknown;
+    deleteError?: unknown;
+    addResponse: Response;
+    updateResponse: Response;
+    deleteResponse: Response;
+    constructor(_connection: IConnection, type?: Constructable<T>);
+    readSingle(query?: ISelectStatement | IWhere | IExecuteStoredProcedureStatement, _parameters?: Parameter[], _options?: ReadonlyRepositoryMappingOptions<T>): Promise<T | undefined>;
+    read(query?: ISelectStatement | IWhere | IExecuteStoredProcedureStatement, _parameters?: Parameter[], _options?: ReadonlyRepositoryMappingOptions<T>): AsyncIterable<T>;
+    create(item: T): Promise<T>;
+    update(item: T, byWhere?: IWhere): Promise<Response>;
+    delete(item: T, byWhere?: IWhere): Promise<Response>;
+    readSingleById: (_id: Scalar | Cells) => Promise<T | undefined>;
+}

package/dist/mocks/mock-select-statement.d.ts

@@ -0,0 +1,10 @@
+import type { ISelectStatement } from "../statements/ISelectStatement.js";
+import type { IStatementVisitor } from "../statements/IStatementVisitor.js";
+import type { IWhere } from "../statements/IWhere.js";
+export declare class MockSelectStatement implements ISelectStatement {
+    text: string;
+    where?: IWhere | undefined;
+    acceptCalls: number;
+    constructor(text: string, where?: IWhere | undefined);
+    accept(_visitor: IStatementVisitor): string;
+}

package/dist/mocks/mock-transaction.d.ts

@@ -0,0 +1,16 @@
+import type { IConnection } from "../IConnection.js";
+import type { ITransaction } from "../ITransaction.js";
+import { IsolationLevel } from "../IsolationLevel.js";
+export declare class MockTransaction implements ITransaction {
+    readonly connection: IConnection;
+    commitCalls: number;
+    abortCalls: number;
+    commitError?: unknown;
+    abortError?: unknown;
+    committed: boolean;
+    aborted: boolean;
+    isolation: IsolationLevel;
+    constructor(connection: IConnection);
+    commit(): Promise<void>;
+    abort(): Promise<void>;
+}

package/dist/mocks/mock-where.d.ts

@@ -0,0 +1,8 @@
+import type { IConditionVisitor } from "../statements/IConditionVisitor.js";
+import type { IWhere } from "../statements/IWhere.js";
+export declare class MockWhere implements IWhere {
+    text: string;
+    acceptCalls: number;
+    constructor(text: string);
+    accept(_visitor: IConditionVisitor): string;
+}

package/dist/parametersToRecord.d.ts

@@ -0,0 +1,2 @@
+import type { Parameter } from "./Parameter.js";
+export declare function parametersToRecord<T>(parameters?: Parameter<T>[] | null): Record<string, T>;

package/dist/readerToAsyncIterable.d.ts

@@ -0,0 +1,2 @@
+import type { IReader } from "./IReader.js";
+export declare function readerToAsyncIterable<T>(reader: IReader<T>): AsyncIterable<T>;

package/dist/splitStatements.d.ts

@@ -0,0 +1 @@
+export declare const splitStatements: (sql: string) => string[];

package/dist/statementParameters.d.ts

@@ -0,0 +1 @@
+export declare const statementParameters: (sql: string) => string[];

package/dist/statementUsesParameter.d.ts

@@ -0,0 +1 @@
+export declare const statementUsesParameter: (sql: string, name: string) => boolean;

package/dist/statements/Aggregate.d.ts

@@ -0,0 +1,6 @@
+export declare const Aggregate: {
+    count: (column: string, alias?: string) => string;
+    sum: (column: string, alias?: string) => string;
+    min: (column: string, alias?: string) => string;
+    max: (column: string, alias?: string) => string;
+};

package/dist/statements/ArrayExpression.d.ts

@@ -0,0 +1,5 @@
+import type { IExpression } from "./IExpression.js";
+export declare class ArrayExpression implements IExpression {
+    readonly elements: IExpression[];
+    constructor(elements: IExpression[]);
+}

package/dist/statements/BulkDeleteStatement.d.ts

@@ -0,0 +1,11 @@
+import type { Parameter } from "../Parameter.js";
+import type { IBulkDeleteStatement } from "./IBulkDeleteStatement.js";
+import type { IStatementVisitor } from "./IStatementVisitor.js";
+export declare class BulkDeleteStatement implements IBulkDeleteStatement {
+    readonly table: string;
+    readonly ids: readonly string[];
+    readonly rows: readonly Parameter[][];
+    constructor(table: string, ids: readonly string[], rows: readonly Parameter[][]);
+    accept: (visitor: IStatementVisitor) => string;
+    get parameters(): Parameter[];
+}

package/dist/statements/BulkDeleteStatementTextRenderer.d.ts

@@ -0,0 +1,4 @@
+import type { BulkDeleteStatement } from "./BulkDeleteStatement.js";
+export declare class BulkDeleteStatementTextRenderer {
+    render: (statement: BulkDeleteStatement) => string;
+}

package/dist/statements/BulkInsertStatement.d.ts

@@ -0,0 +1,12 @@
+import type { Parameter } from "../Parameter.js";
+import type { IBulkInsertStatement } from "./IBulkInsertStatement.js";
+import type { IStatementVisitor } from "./IStatementVisitor.js";
+export declare const flattenBulkParameters: (columns: readonly string[], rows: readonly Parameter[][]) => Parameter[];
+export declare class BulkInsertStatement implements IBulkInsertStatement {
+    readonly table: string;
+    readonly columns: readonly string[];
+    readonly rows: readonly Parameter[][];
+    constructor(table: string, columns: readonly string[], rows: readonly Parameter[][]);
+    accept: (visitor: IStatementVisitor) => string;
+    get parameters(): Parameter[];
+}

package/dist/statements/BulkInsertStatementTextRenderer.d.ts

@@ -0,0 +1,4 @@
+import type { BulkInsertStatement } from "./BulkInsertStatement.js";
+export declare class BulkInsertStatementTextRenderer {
+    render: (statement: BulkInsertStatement) => string;
+}

package/dist/statements/BulkUpdateStatement.d.ts

@@ -0,0 +1,16 @@
+import type { Parameter } from "../Parameter.js";
+import type { IBulkUpdateStatement } from "./IBulkUpdateStatement.js";
+import type { IStatementVisitor } from "./IStatementVisitor.js";
+export type BulkUpdatedRow = {
+    fields: Parameter[];
+    ids: Parameter[];
+};
+export declare class BulkUpdateStatement implements IBulkUpdateStatement {
+    readonly table: string;
+    readonly set: readonly string[];
+    readonly ids: readonly string[];
+    readonly rows: readonly BulkUpdatedRow[];
+    constructor(table: string, set: readonly string[], ids: readonly string[], rows: readonly BulkUpdatedRow[]);
+    accept: (visitor: IStatementVisitor) => string;
+    get parameters(): Parameter[];
+}

package/dist/statements/BulkUpdateStatementTextRenderer.d.ts

@@ -0,0 +1,8 @@
+import type { Cell } from "../converters/Cell.js";
+import type { BulkUpdateStatement } from "./BulkUpdateStatement.js";
+export declare class BulkUpdateStatementTextRenderer {
+    render: (statement: BulkUpdateStatement) => string;
+    protected on: (statement: BulkUpdateStatement) => string;
+    protected source: (statement: BulkUpdateStatement) => string;
+    protected cell: (column: string, index: number, _value: Cell) => string;
+}

package/dist/statements/CheckConstraint.d.ts

@@ -0,0 +1,7 @@
+import type { ITableConstraint } from "./ITableConstraint.js";
+export declare class CheckConstraint implements ITableConstraint {
+    readonly name: string;
+    readonly expression: string;
+    readonly kind: "check";
+    constructor(name: string, expression: string);
+}

package/dist/statements/Cmp.d.ts

@@ -0,0 +1,9 @@
+import type { Cell } from "../converters/Cell.js";
+import type { Condition } from "./Condition.js";
+export type Comparison = (column: string, value: Cell) => Condition;
+export declare const eq: Comparison;
+export declare const ne: Comparison;
+export declare const gt: Comparison;
+export declare const lt: Comparison;
+export declare const ge: Comparison;
+export declare const le: Comparison;

package/dist/statements/Column.d.ts

@@ -0,0 +1,9 @@
+import type { ColumnDefault } from "./ColumnDefault.js";
+import type { NotNull } from "./NotNull.js";
+export interface Column {
+    name: string;
+    type: string;
+    default?: ColumnDefault;
+    notNull?: NotNull;
+    identity?: boolean;
+}

package/dist/statements/ColumnDefault.d.ts

@@ -0,0 +1,5 @@
+export declare class ColumnDefault {
+    readonly value: string;
+    readonly name?: string | undefined;
+    constructor(value: string, name?: string | undefined);
+}

package/dist/statements/Condition.d.ts

@@ -0,0 +1,3 @@
+import type { IExpression } from "./IExpression.js";
+export declare abstract class Condition implements IExpression {
+}

package/dist/statements/ConditionRenderer.d.ts

@@ -0,0 +1,12 @@
+import type { ICondition } from "./ICondition.js";
+import type { IConditionVisitor } from "./IConditionVisitor.js";
+import type { ExpressionRenderer } from "./ExpressionRenderer.js";
+import { Where } from "./Where.js";
+import { WhereText } from "./WhereText.js";
+export declare class ConditionRenderer implements IConditionVisitor {
+    private readonly expressions;
+    constructor(expressions: ExpressionRenderer);
+    render: (condition: ICondition) => string;
+    visit(where: Where): string;
+    visit(where: WhereText): string;
+}

package/dist/statements/CreateIndexStatement.d.ts

@@ -0,0 +1,10 @@
+import type { ICreateIndexStatement } from "./ICreateIndexStatement.js";
+import type { IStatementVisitor } from "./IStatementVisitor.js";
+export declare class CreateIndexStatement implements ICreateIndexStatement {
+    readonly name: string;
+    readonly table: string;
+    readonly columns: string[];
+    readonly unique: boolean;
+    constructor(name: string, table: string, columns: string[], unique?: boolean);
+    accept: (visitor: IStatementVisitor) => string;
+}

package/dist/statements/CreateIndexStatementTextRenderer.d.ts

@@ -0,0 +1,5 @@
+import type { CreateIndexStatement } from "./CreateIndexStatement.js";
+export declare class CreateIndexStatementTextRenderer {
+    render(statement: CreateIndexStatement): string;
+    protected quote(name: string): string;
+}

package/dist/statements/CreateTableStatement.d.ts

@@ -0,0 +1,11 @@
+import type { Column } from "./Column.js";
+import type { ICreateTableStatement } from "./ICreateTableStatement.js";
+import type { IStatementVisitor } from "./IStatementVisitor.js";
+import type { ITableConstraint } from "./ITableConstraint.js";
+export declare class CreateTableStatement implements ICreateTableStatement {
+    readonly table: string;
+    readonly columns: Column[];
+    readonly constraints: ITableConstraint[];
+    constructor(table: string, columns: Column[], constraints?: ITableConstraint[]);
+    accept: (visitor: IStatementVisitor) => string;
+}