@deterministic-code/datasources 0.1.1 → 0.1.3

package/dist/converters/RowTypeConverter.js

@@ -0,0 +1,25 @@
+import { TypeConverter } from "./TypeConverter.js";
+export class RowTypeConverter extends TypeConverter {
+    fields;
+    constructor(fields) {
+        super();
+        this.fields = fields;
+    }
+    static from(converters, columns) {
+        const fields = {};
+        for (const [name, type] of Object.entries(columns)) {
+            const converter = converters[type];
+            if (converter)
+                fields[name] = converter;
+        }
+        return new RowTypeConverter(fields);
+    }
+    convert = (from) => this.apply(from, false);
+    reverseConvert = (to) => this.apply(to, true);
+    apply(row, reverse) {
+        return Object.fromEntries(Object.entries(row).map(([name, value]) => {
+            const converter = this.fields[name];
+            return [name, converter ? (reverse ? converter.reverseConvert(value) : converter.convert(value)) : value];
+        }));
+    }
+}

package/dist/converters/SpecField.d.ts

@@ -0,0 +1,7 @@
+export type FieldSize = number | number[] | "unlimited" | null;
+export type SpecField = {
+    type: string;
+    name?: string;
+    size?: FieldSize;
+    defaultValue?: string | boolean | number | null;
+};

package/dist/converters/SpecField.js

@@ -0,0 +1 @@
+export {};

package/dist/converters/SpecFieldRules.d.ts

@@ -0,0 +1,17 @@
+export type DecimalRule = {
+    kind: "optional";
+    type: string;
+    fallback: string;
+} | {
+    kind: "required";
+    type: string;
+};
+export type SpecFieldRules = {
+    dialectName?: string;
+    stringUnlimited: string;
+    stringSized: (n: number) => string;
+    character?: "CHAR" | "NCHAR";
+    decimal?: DecimalRule;
+    binaryUnlimited?: string;
+    binarySized?: (n: number) => string;
+};

package/dist/converters/SpecFieldRules.js

@@ -0,0 +1 @@
+export {};

package/dist/converters/ToLowerCaseConverter.js

@@ -0,0 +1,4 @@
+export class ToLowerCaseConverter {
+    convert = (from) => from.toLowerCase();
+    reverseConvert = (to) => to;
+}

package/dist/converters/ToUpperCaseConverter.js

@@ -0,0 +1,4 @@
+export class ToUpperCaseConverter {
+    convert = (from) => from.toUpperCase();
+    reverseConvert = (to) => to;
+}

package/dist/converters/TypeConverter.js

@@ -0,0 +1,2 @@
+export class TypeConverter {
+}

package/dist/createCRUDRepositoryOptions.js

@@ -0,0 +1,7 @@
+import { createReadonlyRepositoryMappingOptions, fieldNamesOf, } from "./createReadonlyRepositoryMappingOptions.js";
+export { fieldNamesOf } from "./createReadonlyRepositoryMappingOptions.js";
+export const defaultId = (fields) => fields.includes("id") ? ["id"] : fields.includes("Id") ? ["Id"] : [];
+export const createCRUDRepositoryOptions = (type, rowTypeConverters) => ({
+    ...createReadonlyRepositoryMappingOptions(type, rowTypeConverters),
+    ids: defaultId(fieldNamesOf(type)),
+});

package/dist/createReadonlyRepositoryMappingOptions.js

@@ -0,0 +1,16 @@
+export const fieldNamesOf = (type) => {
+    const instance = new type();
+    return Object.keys(instance).filter((key) => {
+        const value = instance[key];
+        if (Array.isArray(value))
+            return false;
+        if (value !== null && typeof value === "object" && !(value instanceof Date) && !(value instanceof Uint8Array))
+            return "id" in value || "Id" in value;
+        return true;
+    });
+};
+export const createReadonlyRepositoryMappingOptions = (type, rowTypeConverters) => ({
+    type,
+    entity: type.name,
+    rowTypeConverters,
+});

package/dist/dotEnv.js

@@ -0,0 +1,9 @@
+import { existsSync, readFileSync } from "node:fs";
+export const DotEnv = {
+    parse: (text) => Object.fromEntries(text
+        .split(/\r?\n/)
+        .map((raw) => raw.trimStart().split("=", 2))
+        .filter((parts) => parts.length === 2 && !parts[0].startsWith("#") && parts[0].trim() !== "")
+        .map(([key, value]) => [key.trim(), value])),
+    load: (path = ".env") => existsSync(path) ? DotEnv.parse(readFileSync(path, "utf8")) : {},
+};

package/dist/index.d.ts

@@ -9,7 +9,8 @@ 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 { DriverLoader } from "./DriverLoader.js";
+export type { ICreateTableStatement, ICreateIndexStatement, IDropTableStatement, IAlterTableStatement, AlterAction, IDropIndexStatement, IDropTriggerStatement, ICreateTriggerStatement, IIdentityInsertStatement, ICreateCreateStoredProcedureStatement, ICreateReadStoredProcedureStatement, ICreateUpdateStoredProcedureStatement, ICreateDeleteStoredProcedureStatement, ICreateBulkCreateStoredProcedureStatement, ICreateBulkUpdateStoredProcedureStatement, ICreateBulkDeleteStoredProcedureStatement, IDropRoutineStatement, RoutineParameter, 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";
@@ -66,7 +67,7 @@ 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 { ArrayExpression, CheckConstraint, ColumnDefault, Condition, ConditionRenderer, ExpressionRenderer, CreateIndexStatement, CreateTableStatement, CreateTableStatementTextRenderer, CreateIndexStatementTextRenderer, DropTableStatement, DropTableStatementTextRenderer, AlterTableStatement, AlterTableStatementTextRenderer, DropIndexStatement, DropIndexStatementTextRenderer, DropTriggerStatement, DropTriggerStatementTextRenderer, CreateTriggerStatement, CreateTriggerStatementTextRenderer, IdentityInsertStatement, IdentityInsertStatementTextRenderer, CreateCreateStoredProcedureStatement, CreateReadStoredProcedureStatement, CreateUpdateStoredProcedureStatement, CreateDeleteStoredProcedureStatement, CreateBulkCreateStoredProcedureStatement, CreateBulkUpdateStoredProcedureStatement, CreateBulkDeleteStoredProcedureStatement, CreateCreateStoredProcedureStatementTextRenderer, CreateReadStoredProcedureStatementTextRenderer, CreateUpdateStoredProcedureStatementTextRenderer, CreateDeleteStoredProcedureStatementTextRenderer, CreateBulkCreateStoredProcedureStatementTextRenderer, CreateBulkUpdateStoredProcedureStatementTextRenderer, CreateBulkDeleteStoredProcedureStatementTextRenderer, DropRoutineStatement, DropRoutineStatementTextRenderer, 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";
@@ -89,6 +90,12 @@ 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 { type FieldSize, type SpecField, } from "./converters/SpecField.js";
+export type { DecimalRule, SpecFieldRules } from "./converters/SpecFieldRules.js";
+export type { IMapping } from "./converters/IMapping.js";
+export { DeterministicTypeConverter } from "./converters/DeterministicTypeConverter.js";
+export type { DefaultValueOptions } from "./converters/DefaultValueOptions.js";
+export { DefaultValueConverter, EMPTY_UUID, sqlStringLiteral, } from "./converters/DefaultValueConverter.js";
 export { MetaDataRowTypeConverter } from "./converters/MetaDataRowTypeConverter.js";
 export { RowTypeConverter } from "./converters/RowTypeConverter.js";
 export { ToLowerCaseConverter } from "./converters/ToLowerCaseConverter.js";

package/dist/index.js

@@ -0,0 +1,83 @@
+export { execute, executeReader } from "./ICommand.js";
+export { columnType } from "./IDriver.js";
+export { DatasourceFactory } from "./DatasourceFactory.js";
+export { ProviderCatalog } from "./ProviderCatalog.js";
+export { DriverLoader } from "./DriverLoader.js";
+export { ReadonlyRepository, untyped } from "./ReadonlyRepository.js";
+export { RepositoryFactory } from "./RepositoryFactory.js";
+export { RepositoryAccess } from "./RepositoryAccess.js";
+export { RepositoryNotRegisteredError } from "./RepositoryNotRegisteredError.js";
+export { EnrichmentPropertyType } from "./EnrichmentPropertyType.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 { 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 { createCRUDRepositoryOptions } from "./createCRUDRepositoryOptions.js";
+export { createReadonlyRepositoryMappingOptions } from "./createReadonlyRepositoryMappingOptions.js";
+export { Response } from "./Response.js";
+export { UnitOfWorkTransaction } from "./UnitOfWorkTransaction.js";
+export { IsolationLevel } from "./IsolationLevel.js";
+export { ArrayExpression, CheckConstraint, ColumnDefault, Condition, ConditionRenderer, ExpressionRenderer, CreateIndexStatement, CreateTableStatement, CreateTableStatementTextRenderer, CreateIndexStatementTextRenderer, DropTableStatement, DropTableStatementTextRenderer, AlterTableStatement, AlterTableStatementTextRenderer, DropIndexStatement, DropIndexStatementTextRenderer, DropTriggerStatement, DropTriggerStatementTextRenderer, CreateTriggerStatement, CreateTriggerStatementTextRenderer, IdentityInsertStatement, IdentityInsertStatementTextRenderer, CreateCreateStoredProcedureStatement, CreateReadStoredProcedureStatement, CreateUpdateStoredProcedureStatement, CreateDeleteStoredProcedureStatement, CreateBulkCreateStoredProcedureStatement, CreateBulkUpdateStoredProcedureStatement, CreateBulkDeleteStoredProcedureStatement, CreateCreateStoredProcedureStatementTextRenderer, CreateReadStoredProcedureStatementTextRenderer, CreateUpdateStoredProcedureStatementTextRenderer, CreateDeleteStoredProcedureStatementTextRenderer, CreateBulkCreateStoredProcedureStatementTextRenderer, CreateBulkUpdateStoredProcedureStatementTextRenderer, CreateBulkDeleteStoredProcedureStatementTextRenderer, DropRoutineStatement, DropRoutineStatementTextRenderer, 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 { ParameterDirection } from "./ParameterDirection.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";
+import { Datasource } from "./Datasource.js";
+import { DatasourceFactory } from "./DatasourceFactory.js";
+Datasource.create = (options) => DatasourceFactory.create(options);
+export { DatasourceError } from "./DatasourceError.js";
+export { TypeConverter } from "./converters/TypeConverter.js";
+export { DeterministicTypeConverter } from "./converters/DeterministicTypeConverter.js";
+export { DefaultValueConverter, EMPTY_UUID, sqlStringLiteral, } from "./converters/DefaultValueConverter.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 } from "./converters/ChangeCasingConverter.js";
+export { PluralizerConverter } from "./converters/PluralizerConverter.js";
+export { RegexConverter } from "./converters/RegexConverter.js";
+export { ReplaceConverter } from "./converters/ReplaceConverter.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 { 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.js

@@ -0,0 +1,11 @@
+import { ChangeCasingConverter } from "../converters/ChangeCasingConverter.js";
+export class ChangeCasingMapper {
+    forward;
+    reverse;
+    constructor(from, to) {
+        this.forward = new ChangeCasingConverter(to);
+        this.reverse = new ChangeCasingConverter(from);
+    }
+    map = (value) => this.forward.convert(value);
+    reverseMap = (value) => this.reverse.convert(value);
+}

package/dist/mappers/DictionaryMapper.js

@@ -0,0 +1,13 @@
+export class DictionaryMapper {
+    forward = new Map();
+    reverse = new Map();
+    constructor(map) {
+        for (const [from, to] of map) {
+            this.forward.set(from, to);
+            if (!this.reverse.has(to))
+                this.reverse.set(to, from);
+        }
+    }
+    map = (value) => this.forward.get(value) ?? value;
+    reverseMap = (value) => this.reverse.get(value) ?? value;
+}

package/dist/mappers/FlatToNestedMapper.js

@@ -0,0 +1,105 @@
+const stringFields = (fields) => Object.fromEntries(Object.entries(fields).filter((entry) => typeof entry[1] === "string"));
+const destOf = (fields, column) => Object.entries(fields).find(([, source]) => source === column)?.[0] ?? column;
+const cellKey = (value) => (value == null ? null : String(value));
+export class FlatToNestedMapper {
+    spec;
+    scalars;
+    groups;
+    parentDest;
+    constructor(spec) {
+        this.spec = spec;
+        this.scalars = {};
+        this.groups = {};
+        for (const [name, value] of Object.entries(spec.fields)) {
+            if (typeof value === "string")
+                this.scalars[name] = value;
+            else {
+                const fields = stringFields(value.fields);
+                this.groups[name] = { key: value.key, fields, destKey: destOf(fields, value.key) };
+            }
+        }
+        this.parentDest = destOf(this.scalars, spec.key);
+    }
+    map = (rows) => this._collapse(rows);
+    reverseMap = (values) => [...values].flatMap((value) => this.explode(value));
+    _map = (row) => {
+        const dest = {};
+        for (const [name, column] of Object.entries(this.scalars))
+            dest[name] = row[column] ?? null;
+        for (const [name, group] of Object.entries(this.groups)) {
+            const key = row[group.key];
+            dest[name] =
+                key == null
+                    ? []
+                    : [
+                        Object.fromEntries(Object.entries(group.fields).map(([field, column]) => [field, row[column] ?? null])),
+                    ];
+        }
+        return dest;
+    };
+    _collapse = (rows) => {
+        const byParent = new Map();
+        const seen = new Set();
+        for (const raw of rows) {
+            const item = this.mapped(raw) ? raw : this._map(raw);
+            const parent = cellKey(item[this.parentDest]);
+            if (parent == null)
+                continue;
+            const existing = byParent.get(parent);
+            if (!existing) {
+                byParent.set(parent, item);
+                this.mark(seen, parent, item);
+                continue;
+            }
+            this.merge(existing, item, parent, seen);
+        }
+        return [...byParent.values()];
+    };
+    explode = (value) => {
+        const record = value;
+        let rows = [this.scalarsOf(record)];
+        for (const [name, group] of Object.entries(this.groups)) {
+            const children = record[name]?.length
+                ? record[name]
+                : [undefined];
+            rows = rows.flatMap((row) => children.map((child) => this.withChild(row, group, child)));
+        }
+        return rows;
+    };
+    scalarsOf = (record) => {
+        const row = {};
+        for (const [name, column] of Object.entries(this.scalars))
+            row[column] = record[name] ?? null;
+        return row;
+    };
+    withChild = (row, group, child) => {
+        const next = { ...row };
+        for (const [field, column] of Object.entries(group.fields))
+            next[column] = child?.[field] ?? null;
+        return next;
+    };
+    mapped = (row) => Object.keys(this.groups).every((name) => Array.isArray(row[name]));
+    mark = (seen, parent, item) => {
+        const record = item;
+        for (const [name, group] of Object.entries(this.groups))
+            for (const child of record[name]) {
+                const key = cellKey(child[group.destKey]);
+                if (key != null)
+                    seen.add(`${parent}:${name}:${key}`);
+            }
+    };
+    merge = (into, from, parent, seen) => {
+        const dest = into;
+        const source = from;
+        for (const [name, group] of Object.entries(this.groups)) {
+            const children = dest[name];
+            for (const child of source[name]) {
+                const key = cellKey(child[group.destKey]);
+                if (key == null || seen.has(`${parent}:${name}:${key}`))
+                    continue;
+                seen.add(`${parent}:${name}:${key}`);
+                children.push(child);
+            }
+        }
+    };
+}

package/dist/mappers/IFlatToNestedMapper.js

@@ -0,0 +1 @@
+export {};

package/dist/mappers/IMapper.js

@@ -0,0 +1 @@
+export {};

package/dist/mappers/IdentityMapper.js

@@ -0,0 +1,4 @@
+export class IdentityMapper {
+    map = (value) => value;
+    reverseMap = (value) => value;
+}

package/dist/mappers/PluralizerMapper.js

@@ -0,0 +1,6 @@
+import { PluralizerConverter } from "../converters/PluralizerConverter.js";
+export class PluralizerMapper {
+    pluralizer = new PluralizerConverter();
+    map = (value) => this.pluralizer.convert(value);
+    reverseMap = (value) => this.pluralizer.reverseConvert(value);
+}

package/dist/mappers/RowTypeMapper.js

@@ -0,0 +1,7 @@
+import { MetaDataRowTypeConverter as RowTypeConverter } from "../converters/MetaDataRowTypeConverter.js";
+import { TransformMapper } from "./TransformMapper.js";
+export class RowTypeMapper extends TransformMapper {
+    constructor(converter = new RowTypeConverter()) {
+        super((row) => converter.convert(row), (item) => converter.reverseConvert(item));
+    }
+}

package/dist/mappers/TransformConverterMapper.js

@@ -0,0 +1,6 @@
+import { TransformMapper } from "./TransformMapper.js";
+export class TransformConverterMapper extends TransformMapper {
+    constructor(converter, filter) {
+        super((value) => (filter?.(value) !== false ? converter.convert(value) : value), (value) => (filter?.(value) !== false ? converter.reverseConvert(value) : value));
+    }
+}

package/dist/mappers/TransformMapper.js

@@ -0,0 +1,8 @@
+export class TransformMapper {
+    map;
+    reverseMap;
+    constructor(map, reverseMap) {
+        this.map = map;
+        this.reverseMap = reverseMap;
+    }
+}

package/dist/mappers/TypeMap.js

@@ -0,0 +1 @@
+export {};

package/dist/mappers/TypeMapGroup.js

@@ -0,0 +1 @@
+export {};

package/dist/mocks/index.js

@@ -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.js

@@ -0,0 +1,42 @@
+import { CommandMiddlewareHost } from "../CommandMiddlewareHost.js";
+import { DefaultStatementTextRenderer } from "../statements/DefaultStatementTextRenderer.js";
+import { Native } from "../statements/Native.js";
+import { SelectInsertedIdStatement } from "../statements/SelectInsertedIdStatement.js";
+import { MockReader } from "./mock-reader.js";
+export class MockCommand extends CommandMiddlewareHost {
+    connection;
+    executeCalls = [];
+    executeReaderCalls = [];
+    executeError;
+    executeReaderError;
+    response = { result: undefined, rowsAffected: 0 };
+    reader = new MockReader();
+    constructor(connection) {
+        super();
+        this.connection = connection;
+    }
+    executeReaderStatement = (statement, parameters) => this.executeReaderNative(new Native(statement instanceof SelectInsertedIdStatement
+        ? `${statement.table}.${statement.column}`
+        : DefaultStatementTextRenderer.instance.render(statement)), parameters);
+    async executeReaderNative(text, parameters) {
+        return this.run(text.text, parameters, async (query, params) => {
+            this.executeReaderCalls.push({ text: query, parameters: params });
+            if (this.executeReaderError) {
+                throw this.executeReaderError;
+            }
+            const rows = this.reader instanceof MockReader
+                ? this.reader.rows
+                : [];
+            return { value: this.reader, rows };
+        });
+    }
+    async executeNative(text, parameters) {
+        return this.run(text.text, parameters, async (query, params) => {
+            this.executeCalls.push({ text: query, parameters: params });
+            if (this.executeError) {
+                throw this.executeError;
+            }
+            return { value: this.response, rows: [] };
+        });
+    }
+}

package/dist/mocks/mock-connection.js

@@ -0,0 +1,48 @@
+import { DatasourceError } from "../DatasourceError.js";
+import { IsolationLevel } from "../IsolationLevel.js";
+import { MockCommand } from "./mock-command.js";
+import { MockTransaction } from "./mock-transaction.js";
+export class MockConnection {
+    provider;
+    openCalls = 0;
+    closeCalls = 0;
+    startTransactionCalls = 0;
+    openError;
+    closeError;
+    startTransactionError;
+    transaction;
+    command;
+    isOpen = false;
+    constructor(transaction, provider = "mock") {
+        this.provider = provider;
+        this.transaction = transaction ?? new MockTransaction(this);
+    }
+    createCommand = () => this.command ?? new MockCommand(this);
+    async open() {
+        if (this.isOpen)
+            throw new DatasourceError("Connection is already open");
+        this.openCalls += 1;
+        if (this.openError) {
+            throw this.openError;
+        }
+        this.isOpen = true;
+    }
+    async close() {
+        this.closeCalls += 1;
+        if (this.closeError) {
+            throw this.closeError;
+        }
+        this.isOpen = false;
+    }
+    [Symbol.asyncDispose] = () => this.close();
+    async startTransaction(isolation = IsolationLevel.Serializable) {
+        this.startTransactionCalls += 1;
+        if (this.startTransactionError) {
+            throw this.startTransactionError;
+        }
+        if (this.transaction instanceof MockTransaction) {
+            this.transaction.isolation = isolation;
+        }
+        return this.transaction;
+    }
+}

package/dist/mocks/mock-datasource.js

@@ -0,0 +1,44 @@
+import { DatasourceError } from "../DatasourceError.js";
+import { RepositoryFactory } from "../RepositoryFactory.js";
+import { MockCommand } from "./mock-command.js";
+import { MockConnection } from "./mock-connection.js";
+import { MockRepository } from "./mock-repository.js";
+export class MockDatasource {
+    provider;
+    createConnectionCalls = 0;
+    createCommandCalls = [];
+    createRepositoryCalls = [];
+    connection;
+    command;
+    repository;
+    repositories = new RepositoryFactory();
+    constructor(provider = "mock") {
+        this.provider = provider;
+        this.connection = new MockConnection();
+    }
+    createConnection() {
+        this.createConnectionCalls += 1;
+        return Promise.resolve(this.connection);
+    }
+    async createCommand(connection) {
+        this.createCommandCalls.push(connection);
+        if (connection === undefined) {
+            if (this.connection.isOpen)
+                throw new DatasourceError("Connection is already open");
+            await this.connection.open();
+        }
+        return this.command ?? new MockCommand(connection ?? this.connection);
+    }
+    createRepository(typeOrName, connection) {
+        this.createRepositoryCalls.push(connection);
+        if (typeof typeOrName === "string")
+            return this.repositories.create(typeOrName, connection ?? this.connection);
+        return this.repository ??
+            new MockRepository(connection ?? this.connection, typeOrName);
+    }
+    createReadonlyRepository(typeOrName, connection) {
+        if (typeof typeOrName === "string")
+            return this.repositories.createReadonly(typeOrName, connection ?? this.connection);
+        return this.createRepository(typeOrName, connection);
+    }
+}

package/dist/mocks/mock-driver.js

@@ -0,0 +1,15 @@
+import { columnType as identityColumnType } from "../IDriver.js";
+import { MockCommand } from "./mock-command.js";
+import { MockConnection } from "./mock-connection.js";
+import { MockTransaction } from "./mock-transaction.js";
+export class MockDriver {
+    rowTypeConverters = {};
+    columnType = identityColumnType;
+    connection = (_options) => new MockConnection();
+    command = (connection) => new MockCommand(connection);
+    transaction = (connection, isolation = "readCommitted") => {
+        const txn = new MockTransaction(connection);
+        txn.isolation = isolation;
+        return txn;
+    };
+}

package/dist/mocks/mock-reader.js

@@ -0,0 +1,33 @@
+import { readerToAsyncIterable } from "../readerToAsyncIterable.js";
+export class MockReader {
+    rows;
+    current = undefined;
+    nextCalls = 0;
+    nextError;
+    index = -1;
+    constructor(rows = []) {
+        this.rows = rows;
+    }
+    async next() {
+        this.nextCalls += 1;
+        if (this.nextError) {
+            throw this.nextError;
+        }
+        this.index += 1;
+        if (this.index < this.rows.length) {
+            this.current = this.rows[this.index];
+            return true;
+        }
+        this.current = undefined;
+        return false;
+    }
+    read() {
+        return readerToAsyncIterable(this);
+    }
+    async nextResult() {
+        this.current = undefined;
+        return false;
+    }
+    async dispose() { }
+    [Symbol.asyncDispose] = () => this.dispose();
+}