@deterministic-code/datasources 0.1.1 → 0.1.3

package/dist/ReadonlyRepository.js

@@ -0,0 +1,150 @@
+import { executeReader } from "./ICommand.js";
+import { ExecuteStoredProcedureStatement } from "./statements/ExecuteStoredProcedureStatement.js";
+import { DatasourceError } from "./DatasourceError.js";
+import { MetaDataRowTypeConverter } from "./converters/MetaDataRowTypeConverter.js";
+import { SelectStatement } from "./statements/SelectStatement.js";
+import { createReadonlyRepositoryMappingOptions } from "./createReadonlyRepositoryMappingOptions.js";
+import { ReadonlyRepositoryBuilder } from "./ReadonlyRepositoryBuilder.js";
+import { IdentityMapper } from "./mappers/IdentityMapper.js";
+import { StatementMappers } from "./StatementMappers.js";
+import { DefaultReadonlyEnrichmentStrategy } from "./DefaultReadonlyEnrichmentStrategy.js";
+import { StoredEnrichment } from "./StoredEnrichment.js";
+export const untyped = () => Object;
+const storedEnrichments = new WeakMap();
+export const enrichmentsOf = (host) => storedEnrichments.get(host);
+export const isBuilt = (value) => "statements" in value && "objectConverter" in value && "propertyMappings" in value;
+export const builtOf = (typeOrConnectionOrBuilt, connectionOrOptions) => typeof typeOrConnectionOrBuilt === "function"
+    ? connectionOrOptions === undefined
+        ? undefined
+        : new ReadonlyRepositoryBuilder().parts(connectionOrOptions, createReadonlyRepositoryMappingOptions(typeOrConnectionOrBuilt))
+    : isBuilt(typeOrConnectionOrBuilt)
+        ? typeOrConnectionOrBuilt
+        : new ReadonlyRepositoryBuilder().parts(typeOrConnectionOrBuilt, connectionOrOptions);
+export class ReadonlyRepository {
+    type;
+    connection;
+    rowConverter;
+    objectConverter;
+    entityMappers = new IdentityMapper();
+    propertyMappers = new IdentityMapper();
+    statementMappers = new StatementMappers(new IdentityMapper(), new IdentityMapper());
+    readonlyStatements;
+    middlewares = [];
+    constructor(typeOrConnectionOrBuilt, connectionOrOptions) {
+        storedEnrichments.set(this, []);
+        if (typeOrConnectionOrBuilt === undefined) {
+            this.type = untyped();
+            return;
+        }
+        const built = builtOf(typeOrConnectionOrBuilt, connectionOrOptions);
+        if (!built) {
+            this.type = typeOrConnectionOrBuilt;
+            return;
+        }
+        this.type = built.type;
+        this.connection = built.connection;
+        this.rowConverter = built.rowConverter;
+        this.objectConverter = built.objectConverter;
+        this.entityMappers = built.entityMapper;
+        this.propertyMappers = built.propertyMappings;
+        this.statementMappers = new StatementMappers(built.entityMapper, built.propertyMappings);
+        this.readonlyStatements = built.statements;
+    }
+    addMiddleware = (middleware) => {
+        this.middlewares.push(middleware);
+        return this;
+    };
+    addEnriched(enrichment, via, strategy) {
+        const chosen = strategy ?? new DefaultReadonlyEnrichmentStrategy();
+        this.entries().push(new StoredEnrichment(enrichment, (parents, sources) => chosen.apply(via, enrichment, parents, sources)));
+        return this;
+    }
+    async *read(query, parameters, options) {
+        for await (const sourced of this.readTracked(query, parameters, options))
+            yield sourced.item;
+    }
+    async readSingle(query, parameters, options) {
+        for await (const item of this.read(query, parameters, options))
+            return item;
+        return undefined;
+    }
+    get enriched() {
+        return this.entries().length > 0;
+    }
+    command = () => this.middlewares.reduce((command, middleware) => command.addMiddleware(middleware), this.connection.createCommand());
+    column = (property) => this.statementMappers.column(property);
+    cell = (property, value, fieldsApplied, options) => {
+        const objects = options?.objectConverter ?? this.objectConverter;
+        const field = objects instanceof MetaDataRowTypeConverter ? objects.fields[property] : undefined;
+        return field && !fieldsApplied ? field.reverseConvert(value) : value;
+    };
+    entries = () => storedEnrichments.get(this);
+    mappers = (options) => options?.entityMapper === undefined && options?.propertyMappings === undefined
+        ? this.statementMappers
+        : new StatementMappers(options?.entityMapper ?? this.entityMappers, options?.propertyMappings ?? this.propertyMappers);
+    rowConverterOf = (options) => options?.rowConverter ?? this.rowConverter;
+    objects = (options) => options?.objectConverter ??
+        this.objectConverter ??
+        (() => {
+            throw new DatasourceError("Object converter required");
+        })();
+    async *readTracked(query, parameters, options) {
+        const mappers = this.mappers(options);
+        const statement = mappers.apply(query instanceof ExecuteStoredProcedureStatement ? query : this.readQuery(query, mappers, options), (name, value) => this.cell(name, value, false, options));
+        const listed = parameters ??
+            (statement instanceof SelectStatement ? statement.where?.parameters : undefined);
+        yield* this.apply(this.readItems(statement, listed, mappers, this.rowConverterOf(options), this.objects(options)));
+    }
+    async *apply(pairs) {
+        if (!this.enriched) {
+            yield* pairs;
+            return;
+        }
+        yield* this.sourced(pairs);
+    }
+    convertObject = (row, objects) => objects instanceof MetaDataRowTypeConverter
+        ? objects.convert(row, this.type)
+        : objects.convert(row);
+    async *readItems(query, parameters, mappers, rows, objects) {
+        const statement = query ?? this.readonlyStatements.select();
+        const reader = await executeReader(this.command(), statement, parameters);
+        try {
+            while (await reader.next()) {
+                const renamed = this.columnToPropertyName(reader.current ??
+                    (() => {
+                        throw new DatasourceError("Reader current must be a row");
+                    })(), mappers);
+                yield {
+                    item: this.convertObject(rows ? rows.convert(renamed) : renamed, objects),
+                    source: renamed,
+                };
+            }
+        }
+        finally {
+            await reader.dispose();
+        }
+    }
+    async *sourced(pairs) {
+        const items = [];
+        const sources = [];
+        for await (const sourced of pairs) {
+            items.push(sourced.item);
+            sources.push(sourced.source);
+        }
+        await this.fill(items, sources);
+        for (let index = 0; index < items.length; index++)
+            yield { item: items[index], source: sources[index] };
+    }
+    fill = async (parents, sources) => {
+        for (const entry of this.entries())
+            await entry.apply(parents, sources);
+    };
+    columnToPropertyName = (row, mappers) => Object.fromEntries(Object.entries(row).map(([key, value]) => [mappers.property(key), value]));
+    readQuery = (query, mappers, options) => !query
+        ? this.readonlyStatements?.select()
+        : "where" in query
+            ? query
+            : this.readonlyStatements
+                ? this.readonlyStatements.select(mappers.applyWhere(query, (name, cell) => this.cell(name, cell, false, options)))
+                : new SelectStatement({ where: query });
+}

package/dist/ReadonlyRepositoryBuilder.js

@@ -0,0 +1,43 @@
+import { MetaDataRowTypeConverter } from "./converters/MetaDataRowTypeConverter.js";
+import { fieldNamesOf } from "./createReadonlyRepositoryMappingOptions.js";
+import { ReadonlyRepositoryStatements } from "./ReadonlyRepositoryStatements.js";
+import { IdentityMapper } from "./mappers/IdentityMapper.js";
+export class ReadonlyRepositoryBuilder {
+    entityMapper = new IdentityMapper();
+    propertyMapper = new IdentityMapper();
+    parts = (connection, options) => {
+        const rowConverter = options.rowConverter;
+        const objectConverter = options.objectConverter ?? new MetaDataRowTypeConverter();
+        const entityMapper = options.entityMapper ?? new IdentityMapper();
+        const propertyMappings = options.propertyMappings ?? new IdentityMapper();
+        this.entityMapper = entityMapper;
+        this.propertyMapper = propertyMappings;
+        const entity = entityMapper.map(options.entity ?? options.type?.name ?? "");
+        const names = options.readProperties ?? (options.type ? fieldNamesOf(options.type) : []);
+        if (objectConverter instanceof MetaDataRowTypeConverter && options.type) {
+            const instance = new options.type();
+            objectConverter.references.clear();
+            objectConverter.referenceColumns = propertyMappings;
+            for (const name of names) {
+                const value = instance[name];
+                if (value !== null && typeof value === "object" && !Array.isArray(value))
+                    objectConverter.references.add(name);
+            }
+        }
+        const columns = [...names]
+            .map((name) => propertyMappings.map(name))
+            .sort((left, right) => left.localeCompare(right));
+        return {
+            connection,
+            rowConverter,
+            objectConverter,
+            propertyMappings,
+            entityMapper,
+            statements: this.statements(entity, columns),
+            ids: this.ids(options),
+            type: options.type ?? Object,
+        };
+    };
+    ids = (_options) => [];
+    statements = (table, columns) => new ReadonlyRepositoryStatements(table, columns);
+}

package/dist/ReadonlyRepositoryMappingOptions.js

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

package/dist/ReadonlyRepositoryStatements.js

@@ -0,0 +1,10 @@
+import { SelectStatement } from "./statements/SelectStatement.js";
+export class ReadonlyRepositoryStatements {
+    table;
+    readColumns;
+    constructor(table, readColumns) {
+        this.table = table;
+        this.readColumns = readColumns;
+    }
+    select = (where) => new SelectStatement({ table: this.table, fields: [...this.readColumns], where });
+}

package/dist/RepositoryAccess.js

@@ -0,0 +1,12 @@
+export class RepositoryAccess {
+    createRepo;
+    createReadonlyRepo;
+    connection;
+    constructor(createRepo, createReadonlyRepo, connection) {
+        this.createRepo = createRepo;
+        this.createReadonlyRepo = createReadonlyRepo;
+        this.connection = connection;
+    }
+    create = () => this.createRepo(this.connection);
+    createReadonly = () => this.createReadonlyRepo(this.connection);
+}

package/dist/RepositoryFactory.js

@@ -0,0 +1,71 @@
+import { RepositoryAccess } from "./RepositoryAccess.js";
+import { RepositoryNotRegisteredError } from "./RepositoryNotRegisteredError.js";
+const binders = [];
+export class RepositoryFactory {
+    #readonlyByType = new Map();
+    #crudByType = new Map();
+    #byName = new Map();
+    constructor() {
+        this.applyBound();
+    }
+    static bind = (register) => {
+        binders.push(register);
+    };
+    static resetBinders = () => {
+        binders.length = 0;
+    };
+    applyBound() {
+        for (const register of binders)
+            register(this);
+    }
+    register(repositoryOrType, pluralName, create, createReadonly) {
+        if (typeof repositoryOrType !== "string") {
+            this.#put(repositoryOrType, true);
+            return;
+        }
+        const named = { create: create, createReadonly: createReadonly };
+        this.#byName.set(repositoryOrType, named);
+        this.#byName.set(pluralName, named);
+    }
+    create(typeOrName, connection) {
+        if (typeof typeOrName !== "string")
+            return this.#get(this.#crudByType, typeOrName);
+        this.applyBound();
+        return this.#lookup(typeOrName).create(connection);
+    }
+    createReadonly = (name, connection) => {
+        this.applyBound();
+        return this.#lookup(name).createReadonly(connection);
+    };
+    access = (name, connection) => {
+        this.applyBound();
+        const named = this.#lookup(name);
+        return new RepositoryAccess(named.create, named.createReadonly, connection);
+    };
+    has = (name) => {
+        this.applyBound();
+        return this.#byName.has(name);
+    };
+    asReadonly = {
+        register: (repository) => this.#put(repository, false),
+        create: (type) => this.#get(this.#readonlyByType, type),
+    };
+    #put = (repository, crud) => {
+        this.#readonlyByType.set(repository.type, repository);
+        if (!crud)
+            return;
+        this.#crudByType.set(repository.type, repository);
+    };
+    #get = (map, type) => {
+        const repository = map.get(type);
+        if (!repository)
+            throw new RepositoryNotRegisteredError(type.name);
+        return repository;
+    };
+    #lookup = (name) => {
+        const named = this.#byName.get(name);
+        if (!named)
+            throw new RepositoryNotRegisteredError(name);
+        return named;
+    };
+}

package/dist/RepositoryNotRegisteredError.js

@@ -0,0 +1,8 @@
+export class RepositoryNotRegisteredError extends Error {
+    entityTypeName;
+    constructor(entityTypeName) {
+        super(`Repository "${entityTypeName}" is not registered`);
+        this.name = "RepositoryNotRegisteredError";
+        this.entityTypeName = entityTypeName;
+    }
+}

package/dist/RepositoryTree.js

@@ -0,0 +1,6 @@
+export class RepositoryTree {
+    parent;
+    constructor(parent) {
+        this.parent = parent;
+    }
+}

package/dist/RepositoryTreeNode.js

@@ -0,0 +1,12 @@
+export class RepositoryTreeNode {
+    value;
+    propertyName;
+    parent;
+    enrichment;
+    constructor(value, propertyName, parent, enrichment) {
+        this.value = value;
+        this.propertyName = propertyName;
+        this.parent = parent;
+        this.enrichment = enrichment;
+    }
+}

package/dist/Response.js

@@ -0,0 +1,13 @@
+import { ParameterDirection } from "./ParameterDirection.js";
+export class Response {
+    result;
+    rowsAffected;
+    parameters;
+    constructor(result, rowsAffected, parameters) {
+        const returned = parameters?.find((parameter) => parameter.direction === ParameterDirection.ReturnValue)?.value;
+        this.result = result == null && returned != null ? returned : result;
+        this.rowsAffected = rowsAffected;
+        if (parameters !== undefined)
+            this.parameters = parameters;
+    }
+}

package/dist/Row.js

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

package/dist/SingleCommandIBulkWriteStrategy.js

@@ -0,0 +1,21 @@
+const fold = async (items, write) => {
+    let result = null;
+    let rowsAffected = 0;
+    for (const item of items) {
+        const response = await write(item);
+        result = response.result;
+        rowsAffected += response.rowsAffected;
+    }
+    return { result, rowsAffected };
+};
+export class SingleCommandIBulkWriteStrategy {
+    repo;
+    attach = () => { };
+    create = async (items) => {
+        for (const item of items)
+            await this.repo.create(item);
+        return { result: null, rowsAffected: items.length };
+    };
+    update = (items, byWhere) => fold(items, (item) => this.repo.update(item, byWhere));
+    delete = (items, byWhere) => fold(items, (item) => this.repo.delete(item, byWhere));
+}

package/dist/StatementMappers.js

@@ -0,0 +1,88 @@
+import { DeleteStatement } from "./statements/DeleteStatement.js";
+import { InsertStatement } from "./statements/InsertStatement.js";
+import { SelectInsertedIdStatement } from "./statements/SelectInsertedIdStatement.js";
+import { SelectStatement } from "./statements/SelectStatement.js";
+import { UpdateStatement } from "./statements/UpdateStatement.js";
+import { Where } from "./statements/Where.js";
+export class StatementMappers {
+    entityMappers;
+    propertyMappers;
+    constructor(entityMappers, propertyMappers) {
+        this.entityMappers = entityMappers;
+        this.propertyMappers = propertyMappers;
+    }
+    map = (property) => {
+        const dot = lastDot(property);
+        if (dot < 0)
+            return this.propertyMappers.map(property);
+        const qualifier = property.slice(0, dot);
+        const name = property.slice(dot + 1);
+        const mapped = this.propertyMappers.map(name);
+        if (mapped !== name && mapped.includes("."))
+            return mapped;
+        const table = this.entityMappers.map(qualifier);
+        return table === qualifier && mapped === name ? property : `${table}.${mapped}`;
+    };
+    reverseMap = (key) => {
+        const reversed = this.propertyMappers.reverseMap(key);
+        if (reversed !== key && this.propertyMappers.map(reversed) === key)
+            return reversed;
+        const dot = lastDot(key);
+        if (dot < 0)
+            return reversed;
+        const column = key.slice(dot + 1);
+        const name = this.propertyMappers.reverseMap(column);
+        return name !== column && this.propertyMappers.map(name) === column ? name : reversed;
+    };
+    column = (property) => this.map(property);
+    property = (key) => this.reverseMap(key);
+    apply = (query, cell) => {
+        if (query instanceof SelectStatement && query.table)
+            return new SelectStatement({
+                distinct: query.distinct,
+                table: this.entityMappers.map(query.table),
+                fields: query.fields.map(this.mapSelectField),
+                where: query.where instanceof Where ? this.applyWhere(query.where, cell) : query.where,
+                joins: query.joins.map((join) => ({
+                    kind: join.kind,
+                    table: this.entityMappers.map(join.table),
+                    on: join.on ? new Where(join.on).map(this.column, cell).condition : undefined,
+                })),
+                groupBy: query.groupBy.map(this.column),
+                having: query.having instanceof Where ? this.applyWhere(query.having, cell) : query.having,
+                orderBy: query.orderBy.map((order) => ({ column: this.column(order.column), direction: order.direction })),
+                limit: query.limit,
+                offset: query.offset,
+            });
+        if (query instanceof InsertStatement && query.table !== undefined)
+            return new InsertStatement(this.entityMappers.map(query.table), query.fields.map((field) => ({ name: this.column(field.name), value: field.value })));
+        if (query instanceof UpdateStatement && query.table !== undefined)
+            return new UpdateStatement(this.entityMappers.map(query.table), query.fields.map((field) => ({ name: this.column(field.name), value: field.value })), query.where instanceof Where ? this.applyWhere(query.where, cell) : query.where);
+        if (query instanceof DeleteStatement && query.table !== undefined)
+            return new DeleteStatement(this.entityMappers.map(query.table), query.where instanceof Where ? this.applyWhere(query.where, cell) : query.where);
+        if (query instanceof SelectInsertedIdStatement)
+            return new SelectInsertedIdStatement(this.entityMappers.map(query.table), this.column(query.column));
+        return query;
+    };
+    applyWhere = (where, cell) => where instanceof Where ? where.map(this.column, cell) : where;
+    mapSelectField = (field) => {
+        const asIndex = field.toUpperCase().indexOf(" AS ");
+        if (asIndex >= 0) {
+            const expression = field.slice(0, asIndex).trim();
+            const alias = field.slice(asIndex + 4).trim();
+            return `${this.map(expression)} AS ${alias}`;
+        }
+        return this.map(field);
+    };
+}
+const lastDot = (name) => {
+    let quoted = false;
+    let dot = -1;
+    for (let i = 0; i < name.length; i++) {
+        if (name[i] === '"')
+            quoted = !quoted;
+        if (name[i] === "." && !quoted)
+            dot = i;
+    }
+    return dot;
+};

package/dist/StoredEnrichment.js

@@ -0,0 +1,12 @@
+export class StoredEnrichment {
+    enrichment;
+    apply;
+    persist;
+    link;
+    constructor(enrichment, apply, persist, link) {
+        this.enrichment = enrichment;
+        this.apply = apply;
+        this.persist = persist;
+        this.link = link;
+    }
+}

package/dist/StoredProcedureBulkWriteStrategy.js

@@ -0,0 +1,143 @@
+import { DatasourceError } from "./DatasourceError.js";
+import { ExecuteStoredProcedureStatement } from "./statements/ExecuteStoredProcedureStatement.js";
+import { execute } from "./ICommand.js";
+import { repositoryParts } from "./CRUDRepositoryBuilder.js";
+import { MetaDataRowTypeConverter } from "./converters/MetaDataRowTypeConverter.js";
+import { afterBulkWrite } from "./BulkWriteEnrichment.js";
+import { ParameterDirection } from "./ParameterDirection.js";
+const empty = () => ({ result: null, rowsAffected: 0 });
+const json = (rows) => `[${rows.map(object).join(",")}]`;
+const object = (row) => `{${Object.entries(row)
+    .sort(([left], [right]) => left.localeCompare(right))
+    .map(([key, value]) => `${quote(key)}:${scalar(value)}`)
+    .join(",")}}`;
+const scalar = (value) => {
+    if (value === null || value === undefined)
+        return "null";
+    if (typeof value === "boolean")
+        return value ? "true" : "false";
+    if (typeof value === "number")
+        return Number.isFinite(value) ? JSON.stringify(value) : fail();
+    if (typeof value === "bigint")
+        return value.toString();
+    if (typeof value === "string")
+        return quote(value);
+    if (value instanceof Date)
+        return quote(roundTrip(value));
+    if (value instanceof Uint8Array)
+        return quote(base64(value));
+    return fail();
+};
+const fail = () => {
+    throw new DatasourceError("Unsupported bulk payload value");
+};
+const roundTrip = (date) => date.toISOString().replace(/\.(\d{3})Z$/, (_, fraction) => `.${fraction}0000Z`);
+const base64 = (bytes) => btoa(Array.from(bytes, (byte) => String.fromCharCode(byte)).join(""));
+const quote = (text) => {
+    let result = "\"";
+    for (const ch of text) {
+        result += ({
+            "\\": "\\\\",
+            "\"": "\\\"",
+            "\b": "\\b",
+            "\f": "\\f",
+            "\n": "\\n",
+            "\r": "\\r",
+            "\t": "\\t",
+        }[ch] ?? (ch < " " ? `\\u${ch.charCodeAt(0).toString(16).padStart(4, "0")}` : ch));
+    }
+    return `${result}"`;
+};
+export class StoredProcedureBulkWriteStrategy {
+    createName;
+    updateName;
+    deleteName;
+    repo;
+    command;
+    options;
+    attach = (command, options) => {
+        this.command = command;
+        this.options = options;
+    };
+    constructor(createName, updateName, deleteName) {
+        this.createName = createName;
+        this.updateName = updateName;
+        this.deleteName = deleteName;
+    }
+    create = (items) => this.then(this.call(this.createName, items, true), items, "create");
+    update = (items, _byWhere) => this.then(this.call(this.updateName, items), items, "update");
+    delete = (items, _byWhere) => this.then(this.call(this.deleteName, items), items, "delete");
+    then = async (write, items, mode) => {
+        const response = await write;
+        await afterBulkWrite(this.repo, this.options, items, mode);
+        return response;
+    };
+    call = async (name, items, generated = false) => {
+        if (items.length === 0)
+            return empty();
+        const payload = { name: "payload", value: json(items.map((item) => this.rowOf(item, generated))) };
+        const parameters = generated && this.ids().length === 1
+            ? [payload, { name: "ids", value: null, direction: ParameterDirection.InputOutput }]
+            : [payload];
+        const response = await execute(this.command, new ExecuteStoredProcedureStatement(name, parameters), parameters);
+        if (generated)
+            this.applyIds(items, response.parameters);
+        return response;
+    };
+    ids = () => this.options.ids ?? this.repo.ids ?? ["id"];
+    rowOf = (item, create = false) => {
+        const stored = this.reverse(item);
+        const statements = repositoryParts(this.command.connection, this.options).statements;
+        const row = {};
+        for (const name of statements.readColumns) {
+            if (create && this.identity(name) && !assigned(stored[name] ?? stored[this.ids()[0]]))
+                continue;
+            const match = Object.entries(stored).find(([key]) => this.column(key) === name);
+            row[name] = match?.[1] ?? null;
+        }
+        return row;
+    };
+    identity = (column) => this.ids().length === 1 && this.ids()[0] === column;
+    applyIds = (items, parameters) => {
+        if (this.ids().length !== 1)
+            return;
+        const found = parameters?.find((parameter) => parameter.name === "ids");
+        const list = parseIds(found?.value);
+        const column = this.ids()[0];
+        for (let index = 0; index < items.length && index < list.length; index++)
+            stamp(items[index], column, list[index]);
+    };
+    column = (property) => this.options.propertyMappings?.map(property) ?? property;
+    reverse = (item) => {
+        const objects = this.options.objectConverter ?? new MetaDataRowTypeConverter();
+        const row = objects.reverseConvert(item);
+        return this.options.rowConverter ? this.options.rowConverter.reverseConvert(row) : row;
+    };
+}
+const assigned = (value) => {
+    if (value === null || value === undefined)
+        return false;
+    if (value === 0 || value === 0n)
+        return false;
+    if (typeof value === "string")
+        return value.length > 0;
+    return true;
+};
+const parseIds = (value) => {
+    const text = typeof value === "string" ? value.trim()
+        : typeof value === "number" || typeof value === "bigint" ? String(value)
+            : "";
+    if (text === "" || text === "[]" || text === "null")
+        return [];
+    return text
+        .replace(/^\[/, "")
+        .replace(/\]$/, "")
+        .split(",")
+        .map((part) => part.trim())
+        .filter(Boolean)
+        .map((part) => Number(part));
+};
+const stamp = (item, column, id) => {
+    const key = column in item ? column : "id" in item ? "id" : "Id" in item ? "Id" : column;
+    item[key] = id;
+};

package/dist/StreamingReader.js

@@ -0,0 +1,53 @@
+import { readerToAsyncIterable } from "./readerToAsyncIterable.js";
+export class StreamingReader {
+    pull;
+    advance;
+    close;
+    current = undefined;
+    closed = false;
+    constructor(pull, advance, close = async () => { }) {
+        this.pull = pull;
+        this.advance = advance;
+        this.close = close;
+    }
+    async next() {
+        this.current = await this.pull();
+        return this.current !== undefined;
+    }
+    read() {
+        return readerToAsyncIterable(this);
+    }
+    async nextResult() {
+        this.current = undefined;
+        return this.advance();
+    }
+    async dispose() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        await this.close();
+    }
+    [Symbol.asyncDispose] = () => this.dispose();
+}
+export const statementReader = (statements, load) => {
+    let index = 0;
+    let rows;
+    const closeRows = async () => {
+        await rows?.return?.();
+        rows = undefined;
+    };
+    return new StreamingReader(async () => {
+        if (index >= statements.length)
+            return undefined;
+        const sql = statements[index];
+        if (!sql)
+            return undefined;
+        rows ??= load(sql)[Symbol.asyncIterator]();
+        const step = await rows.next();
+        return step.done ? undefined : step.value;
+    }, async () => {
+        await closeRows();
+        index += 1;
+        return index < statements.length;
+    }, closeRows);
+};