@deterministic-code/datasources 0.1.10 → 0.1.12

package/dist/BatchCommandIBulkWriteStrategy.d.ts

@@ -27,6 +27,7 @@ export declare class BatchCommandIBulkWriteStrategy<T extends object> implements
     private statements;
     private get ids();
     private reverse;
+    private writable;
     private fields;
     private cell;
     private idsWhere;

package/dist/BatchCommandIBulkWriteStrategy.js

@@ -9,6 +9,7 @@ const empty = () => ({ result: null, rowsAffected: 0 });
 const budget = 8000;
 const maxRows = 250;
 const assigned = (value) => value !== null && value !== "" && value !== 0 && value !== 0n;
+const listed = (list, col, fallback) => list === undefined ? fallback : list.includes(col);
 const columnsOf = (rows) => {
     const seen = new Set();
     const columns = [];
@@ -83,12 +84,12 @@ export class BatchCommandIBulkWriteStrategy {
     };
     mappedInsert = (item) => {
         const record = this.reverse(item);
-        const statement = this.statements().insert(this.fields(record, (col) => !this.ids.includes(col) || assigned(record[col] ?? null)));
+        const statement = this.statements().insert(this.fields(record, (col) => listed(this.options.createProperties, col, !this.ids.includes(col) || assigned(record[col] ?? null))));
         return { table: statement.table, fields: statement.fields };
     };
     mappedUpdate = (item) => {
         const record = this.reverse(item);
-        const fields = this.fields(record, (col) => !this.ids.includes(col));
+        const fields = this.fields(record, (col) => listed(this.options.updateProperties, col, !this.ids.includes(col)));
         if (fields.length === 0)
             throw new DatasourceError("Update requires at least one non-Id field");
         const statement = this.statements().update(fields, this.idsWhere(record), (name, value) => this.cell(name, value, true));
@@ -101,7 +102,7 @@ export class BatchCommandIBulkWriteStrategy {
     };
     updateCommand = (item, byWhere) => {
         const record = this.reverse(item);
-        const fields = this.fields(record, (col) => !this.ids.includes(col));
+        const fields = this.fields(record, (col) => listed(this.options.updateProperties, col, !this.ids.includes(col)));
         if (fields.length === 0)
             throw new DatasourceError("Update requires at least one non-Id field");
         const statement = this.statements().update(fields, byWhere ?? this.idsWhere(record), (name, value) => this.cell(name, value, byWhere === undefined));
@@ -127,8 +128,15 @@ export class BatchCommandIBulkWriteStrategy {
         const row = objects.reverseConvert(item);
         return this.options.rowConverter ? this.options.rowConverter.reverseConvert(row) : row;
     };
+    writable = (key) => {
+        const columns = this.statements().readColumns;
+        const map = this.options.propertyMappings;
+        return (columns.length === 0 ||
+            columns.includes(key) ||
+            (map !== undefined && columns.some((name) => map.map(name) === key)));
+    };
     fields = (record, include) => Object.entries(record)
-        .filter(([key, value]) => include(key) && value !== null && value !== undefined)
+        .filter(([key, value]) => include(key) && this.writable(key) && value !== null && value !== undefined)
         .sort(([left], [right]) => left.localeCompare(right))
         .map(([name, value]) => ({ name, value: this.cell(name, value, true) }));
     cell = (property, value, fieldsApplied) => fieldsApplied

package/dist/CRUDRepository.d.ts

@@ -12,6 +12,8 @@ import type { IReadonlyEnrichmentStrategy } from "./IReadonlyEnrichmentStrategy.
 import type { IReadonlyRepository } from "./IReadonlyRepository.js";
 export declare class CRUDRepository<T = Cells> extends ReadonlyRepository<T> implements ICRUDRepository<T> {
     readonly ids: readonly string[];
+    private readonly createProperties?;
+    private readonly updateProperties?;
     private readonly crudStatements;
     private readonly tree;
     private readonly write;

package/dist/CRUDRepository.js

@@ -11,8 +11,14 @@ import { UnitOfWorkTransaction } from "./UnitOfWorkTransaction.js";
 import { RepositoryTree } from "./RepositoryTree.js";
 import { RepositoryTreeNode } from "./RepositoryTreeNode.js";
 const assigned = (value) => value !== null && value !== "" && value !== 0 && value !== 0n;
-const fieldsOf = (record, include, cell, enrichmentInto) => Object.entries(record)
-    .filter(([key, value]) => include(key) && !enrichmentInto(key) && value !== null && value !== undefined)
+const listed = (list, col, fallback) => list === undefined ? fallback : list.includes(col);
+const writable = (key, columns, column) => columns.length === 0 || columns.includes(key) || columns.some((name) => column(name) === key);
+const fieldsOf = (record, include, cell, enrichmentInto, columns, column) => Object.entries(record)
+    .filter(([key, value]) => include(key) &&
+    writable(key, columns, column) &&
+    !enrichmentInto(key) &&
+    value !== null &&
+    value !== undefined)
     .sort(([left], [right]) => left.localeCompare(right))
     .map(([name, value]) => ({ name, value: cell(name, value, true) }));
 const isCells = (id) => typeof id === "object" && id !== null;
@@ -29,6 +35,8 @@ const identified = (row, column) => {
 const scalarOf = (value) => value === undefined || value === null || typeof value === "object" ? undefined : value;
 export class CRUDRepository extends ReadonlyRepository {
     ids;
+    createProperties;
+    updateProperties;
     crudStatements;
     tree;
     write;
@@ -40,6 +48,8 @@ export class CRUDRepository extends ReadonlyRepository {
         const opened = repositoryParts(typeOrConnection, options);
         super(opened.built);
         this.ids = opened.built.ids;
+        this.createProperties = options.createProperties;
+        this.updateProperties = options.updateProperties;
         this.crudStatements = opened.statements;
         this.tree = new RepositoryTree(new RepositoryTreeNode(this, ""));
         this.write = options.write ?? new DefaultWriteEnrichmentStrategy();
@@ -101,7 +111,7 @@ export class CRUDRepository extends ReadonlyRepository {
     readSingleById = async (id) => this.readSingle(this.byId(id));
     insert = async (item) => {
         const record = this.reverseConvert(item);
-        const fields = fieldsOf(record, (col) => !this.ids.includes(col) || assigned(record[col] ?? null), this.cell, this.enrichmentInto);
+        const fields = fieldsOf(record, (col) => listed(this.createProperties, col, !this.ids.includes(col) || assigned(record[col] ?? null)), this.cell, this.enrichmentInto, this.crudStatements.readColumns, this.column);
         const statement = this.crudStatements.insert(fields);
         const response = await execute(this.command(), statement, statement.fields);
         if (this.ids.length === 1 && !fields.some((field) => field.name === this.ids[0]))
@@ -136,7 +146,7 @@ export class CRUDRepository extends ReadonlyRepository {
     idValue = (item) => scalarOf(item[this.ids[0]]);
     save = async (item, byWhere) => {
         const record = this.reverseConvert(item);
-        const fields = fieldsOf(record, (col) => !this.ids.includes(col), this.cell, this.enrichmentInto);
+        const fields = fieldsOf(record, (col) => listed(this.updateProperties, col, !this.ids.includes(col)), this.cell, this.enrichmentInto, this.crudStatements.readColumns, this.column);
         if (fields.length === 0)
             throw new DatasourceError("Update requires at least one non-Id field");
         const statement = this.crudStatements.update(fields, byWhere ?? this.idWhere(record), (name, value) => this.cell(name, value, byWhere === undefined));
@@ -149,7 +159,7 @@ export class CRUDRepository extends ReadonlyRepository {
         const parameters = listed.length
             ? listed
             : DefaultStatementTextRenderer.instance.render(statement).includes("$")
-                ? fieldsOf(record, () => true, this.cell, this.enrichmentInto)
+                ? fieldsOf(record, () => true, this.cell, this.enrichmentInto, this.crudStatements.readColumns, this.column)
                 : [];
         return execute(this.command(), statement, parameters);
     };

package/dist/CRUDRepositoryBuilder.d.ts

@@ -12,7 +12,11 @@ export declare const repositoryParts: <T>(typeOrConnection: Constructable<T> | I
     statements: CRUDRepositoryStatements;
 };
 export declare class CRUDRepositoryBuilder<T = object> extends ReadonlyRepositoryBuilder<T> {
+    private readonly factory;
     crudStatements?: CRUDRepositoryStatements;
+    add(options: CRUDRepositoryOptions<T>): this;
+    add(dialect: string, options: CRUDRepositoryOptions<T>): this;
+    for: (connection: IConnection) => CRUDRepositoryOptions<T>;
     protected ids: (options: ReadonlyRepositoryMappingOptions<T>) => string[];
     protected statements: (table: string, columns: string[]) => ReadonlyRepositoryStatements;
     build: (connection: IConnection, options: CRUDRepositoryOptions<T>) => CRUDRepository<T>;

package/dist/CRUDRepositoryBuilder.js

@@ -3,6 +3,7 @@ import { CRUDRepository } from "./CRUDRepository.js";
 import { CRUDRepositoryStatements } from "./CRUDRepositoryStatements.js";
 import { ReadonlyRepositoryBuilder } from "./ReadonlyRepositoryBuilder.js";
 import { ReadonlyRepositoryStatements } from "./ReadonlyRepositoryStatements.js";
+import { RepositoryBuilderOptionsFactory } from "./RepositoryBuilderOptionsFactory.js";
 const isCrud = (options) => "ids" in options || "write" in options;
 const withIds = (options) => "ids" in options
     ? options
@@ -18,7 +19,15 @@ export const repositoryParts = (typeOrConnection, connectionOrOptions) => {
     return { built, statements: builder.crudStatements };
 };
 export class CRUDRepositoryBuilder extends ReadonlyRepositoryBuilder {
+    factory = new RepositoryBuilderOptionsFactory();
     crudStatements;
+    add(dialectOrOptions, options) {
+        typeof dialectOrOptions === "string"
+            ? this.factory.add(dialectOrOptions, options)
+            : this.factory.add(dialectOrOptions);
+        return this;
+    }
+    for = (connection) => this.factory.for(connection.provider);
     ids = (options) => isCrud(options)
         ? (options.ids ?? (options.type ? defaultId(fieldNamesOf(options.type)) : ["id"]))
         : [];

package/dist/CRUDRepositoryOptions.d.ts

@@ -3,5 +3,7 @@ import type { Cells } from "./converters/Cell.js";
 import type { IWriteEnrichmentStrategy } from "./IWriteEnrichmentStrategy.js";
 export type CRUDRepositoryOptions<T = Cells> = ReadonlyRepositoryMappingOptions<T> & {
     ids?: string[];
+    createProperties?: string[];
+    updateProperties?: string[];
     write?: IWriteEnrichmentStrategy<T>;
 };

package/dist/NestedSelectBuilder.d.ts

@@ -0,0 +1,6 @@
+import type { NestedSelectBuilderOptions } from "./NestedSelectBuilderOptions.js";
+import type { NestedSelectStatement } from "./NestedSelectStatement.js";
+import type { NestedSelectType } from "./NestedSelectType.js";
+export declare class NestedSelectBuilder {
+    build(root: NestedSelectType, options?: NestedSelectBuilderOptions): NestedSelectStatement;
+}

package/dist/NestedSelectBuilder.js

@@ -0,0 +1,63 @@
+import { selectFieldAliases } from "./SelectFieldAliases.js";
+import { Join } from "./statements/Join.js";
+import { SelectStatement } from "./statements/SelectStatement.js";
+export class NestedSelectBuilder {
+    build(root, options) {
+        const stopAt = options?.stopAt ?? [];
+        const fields = [];
+        const joins = [];
+        walk(root, root.name, root.name, "", stopAt, false, fields, joins);
+        const aliases = selectFieldAliases(root.name, fields);
+        const byPath = Object.fromEntries(fields.map((field, i) => [field, aliases[i]]));
+        return {
+            select: new SelectStatement({
+                table: root.name,
+                fields,
+                joins,
+                where: options?.where,
+            }),
+            map: mapOf(root, root.name, "", stopAt, byPath),
+        };
+    }
+}
+const walk = (type, fieldPrefix, joinEntity, stopPrefix, stopAt, outer, fields, joins) => {
+    for (const property of type.properties)
+        fields.push(`${fieldPrefix}.${property}`);
+    for (const relation of type.relations) {
+        const path = stopPrefix.length === 0 ? relation.name : `${stopPrefix}.${relation.name}`;
+        if (stopped(stopAt, path))
+            continue;
+        const list = relation.kind === "list";
+        joins.push(list || outer
+            ? Join.left(relation.target.name, `${joinEntity}.${relation.from}`, `${relation.target.name}.${relation.to}`)
+            : Join.inner(relation.target.name, `${joinEntity}.${relation.from}`, `${relation.target.name}.${relation.to}`));
+        walk(relation.target, `${fieldPrefix}.${relation.target.name}`, relation.target.name, path, stopAt, outer || list, fields, joins);
+    }
+};
+const mapOf = (type, fieldPrefix, stopPrefix, stopAt, aliases) => ({
+    key: aliases[`${fieldPrefix}.${type.key}`],
+    fields: fieldsOf(type, fieldPrefix, stopPrefix, stopAt, aliases),
+});
+const fieldsOf = (type, fieldPrefix, stopPrefix, stopAt, aliases) => {
+    const fields = {};
+    for (const property of type.properties) {
+        const alias = aliases[`${fieldPrefix}.${property}`];
+        fields[alias] = alias;
+    }
+    for (const relation of type.relations) {
+        const path = stopPrefix.length === 0 ? relation.name : `${stopPrefix}.${relation.name}`;
+        if (stopped(stopAt, path))
+            continue;
+        const childPrefix = `${fieldPrefix}.${relation.target.name}`;
+        if (relation.kind === "list") {
+            fields[relation.name] = {
+                key: aliases[`${childPrefix}.${relation.target.key}`],
+                fields: fieldsOf(relation.target, childPrefix, path, stopAt, aliases),
+            };
+            continue;
+        }
+        Object.assign(fields, fieldsOf(relation.target, childPrefix, path, stopAt, aliases));
+    }
+    return fields;
+};
+const stopped = (stopAt, path) => stopAt.some((item) => item === path || path.startsWith(`${item}.`));

package/dist/NestedSelectBuilderOptions.d.ts

@@ -0,0 +1,5 @@
+import type { IWhere } from "./statements/IWhere.js";
+export type NestedSelectBuilderOptions = {
+    where?: IWhere;
+    stopAt?: readonly string[];
+};

package/dist/NestedSelectBuilderOptions.js

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

package/dist/NestedSelectRelation.d.ts

@@ -0,0 +1,9 @@
+import type { NestedSelectRelationKind } from "./NestedSelectRelationKind.js";
+import type { NestedSelectType } from "./NestedSelectType.js";
+export type NestedSelectRelation = {
+    name: string;
+    kind: NestedSelectRelationKind;
+    from: string;
+    to: string;
+    target: NestedSelectType;
+};

package/dist/NestedSelectRelation.js

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

package/dist/NestedSelectRelationKind.d.ts

@@ -0,0 +1 @@
+export type NestedSelectRelationKind = "object" | "list";

package/dist/NestedSelectRelationKind.js

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

package/dist/NestedSelectStatement.d.ts

@@ -0,0 +1,10 @@
+import type { TypeMapGroup } from "./mappers/TypeMapGroup.js";
+import type { SelectStatement } from "./statements/SelectStatement.js";
+export type NestedSelectMapField = string | TypeMapGroup<Record<string, string>>;
+export type NestedSelectStatement = {
+    select: SelectStatement;
+    map: {
+        key: string;
+        fields: Record<string, NestedSelectMapField>;
+    };
+};

package/dist/NestedSelectStatement.js

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

package/dist/NestedSelectType.d.ts

@@ -0,0 +1,7 @@
+import type { NestedSelectRelation } from "./NestedSelectRelation.js";
+export type NestedSelectType = {
+    name: string;
+    key: string;
+    properties: readonly string[];
+    relations: readonly NestedSelectRelation[];
+};

package/dist/NestedSelectType.js

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

package/dist/RepositoryBuilderOptionsFactory.d.ts

@@ -0,0 +1,8 @@
+import type { CRUDRepositoryOptions } from "./CRUDRepositoryOptions.js";
+export declare class RepositoryBuilderOptionsFactory<T = object> {
+    private fallback?;
+    private readonly items;
+    add(options: CRUDRepositoryOptions<T>): this;
+    add(dialect: string, options: CRUDRepositoryOptions<T>): this;
+    for: (provider: string) => CRUDRepositoryOptions<T>;
+}

package/dist/RepositoryBuilderOptionsFactory.js

@@ -0,0 +1,12 @@
+import { DatasourceError } from "./DatasourceError.js";
+export class RepositoryBuilderOptionsFactory {
+    fallback;
+    items = new Map();
+    add(dialectOrOptions, options) {
+        typeof dialectOrOptions === "string"
+            ? this.items.set(dialectOrOptions, options)
+            : (this.fallback = dialectOrOptions);
+        return this;
+    }
+    for = (provider) => this.items.get(provider) ?? this.fallback ?? (() => { throw new DatasourceError("repository options required"); })();
+}

package/dist/SelectFieldAliases.d.ts

@@ -0,0 +1,14 @@
+export type PathParts = {
+    owner: string;
+    last: string;
+    root: boolean;
+};
+export declare const selectFieldAliases: (table: string, fields: readonly string[], aliases?: readonly (string | undefined)[]) => (string | undefined)[];
+export declare const applySelectFieldAlias: (field: string, alias?: string) => string;
+export declare const pathOf: (field: string, table: string) => PathParts | undefined;
+export declare const functionOf: (field: string) => {
+    name: string;
+    inner: string;
+} | undefined;
+export declare const asIndexOf: (field: string) => number;
+export declare const segments: (name: string) => string[];

package/dist/SelectFieldAliases.js

@@ -0,0 +1,62 @@
+export const selectFieldAliases = (table, fields, aliases = []) => {
+    const result = fields.map(() => undefined);
+    const used = new Set();
+    for (const [i] of fields.entries()) {
+        const alias = aliases[i];
+        if (alias !== undefined) {
+            result[i] = alias;
+            used.add(alias);
+        }
+    }
+    for (const [i, field] of fields.entries()) {
+        const path = pathOf(field, table);
+        if (result[i] === undefined && path?.root) {
+            result[i] = path.last;
+            used.add(path.last);
+        }
+    }
+    for (const [i, field] of fields.entries()) {
+        const path = pathOf(field, table);
+        if (result[i] === undefined && path && !path.root) {
+            const alias = used.has(path.last) ? `${path.owner}${path.last}` : path.last;
+            result[i] = alias;
+            used.add(alias);
+        }
+    }
+    return result;
+};
+export const applySelectFieldAlias = (field, alias) => alias === undefined ? field : `${field} AS ${alias}`;
+export const pathOf = (field, table) => {
+    if (asIndexOf(field) >= 0 || field.includes("("))
+        return undefined;
+    const parts = segments(field);
+    if (parts.length < 2)
+        return undefined;
+    return {
+        owner: parts[parts.length - 2],
+        last: parts[parts.length - 1],
+        root: parts.length === 2 && parts[0] === table,
+    };
+};
+export const functionOf = (field) => {
+    const open = field.indexOf("(");
+    return open <= 0 || !field.endsWith(")")
+        ? undefined
+        : { name: field.slice(0, open).trim(), inner: field.slice(open + 1, -1).trim() };
+};
+export const asIndexOf = (field) => field.toUpperCase().indexOf(" AS ");
+export const segments = (name) => {
+    const parts = [];
+    let quoted = false;
+    let start = 0;
+    for (let i = 0; i < name.length; i++) {
+        if (name[i] === '"')
+            quoted = !quoted;
+        if (name[i] === "." && !quoted) {
+            parts.push(name.slice(start, i));
+            start = i + 1;
+        }
+    }
+    parts.push(name.slice(start));
+    return parts;
+};

package/dist/StatementMappers.d.ts

@@ -12,5 +12,6 @@ export declare class StatementMappers implements IMapper<string, string> {
     property: (key: string) => string;
     apply: (query: IStatement | undefined, cell: (property: string, value: Cell) => Cell) => IStatement | undefined;
     applyWhere: (where: IWhere | undefined, cell: (property: string, value: Cell) => Cell) => IWhere | undefined;
+    private mapSelectFields;
     private mapSelectField;
 }

package/dist/StatementMappers.js

@@ -1,3 +1,5 @@
+import { DatasourceError } from "./DatasourceError.js";
+import { applySelectFieldAlias, asIndexOf, functionOf, segments, selectFieldAliases } from "./SelectFieldAliases.js";
 import { DeleteStatement } from "./statements/DeleteStatement.js";
 import { InsertStatement } from "./statements/InsertStatement.js";
 import { SelectInsertedIdStatement } from "./statements/SelectInsertedIdStatement.js";
@@ -12,25 +14,25 @@ export class StatementMappers {
         this.propertyMappers = propertyMappers;
     }
     map = (property) => {
-        const dot = lastDot(property);
-        if (dot < 0)
+        const parts = segments(property);
+        if (parts.length < 2)
             return this.propertyMappers.map(property);
-        const qualifier = property.slice(0, dot);
-        const name = property.slice(dot + 1);
+        const qualifier = parts[parts.length - 2];
+        const name = parts[parts.length - 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}`;
+        return table === qualifier && mapped === name ? `${qualifier}.${name}` : `${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)
+        const parts = segments(key);
+        if (parts.length < 2)
             return reversed;
-        const column = key.slice(dot + 1);
+        const column = parts[parts.length - 1];
         const name = this.propertyMappers.reverseMap(column);
         return name !== column && this.propertyMappers.map(name) === column ? name : reversed;
     };
@@ -41,7 +43,7 @@ export class StatementMappers {
             return new SelectStatement({
                 distinct: query.distinct,
                 table: this.entityMappers.map(query.table),
-                fields: query.fields.map(this.mapSelectField),
+                fields: this.mapSelectFields(query.table, query.fields, query.aliases),
                 where: query.where instanceof Where ? this.applyWhere(query.where, cell) : query.where,
                 joins: query.joins.map((join) => ({
                     kind: join.kind,
@@ -65,24 +67,15 @@ export class StatementMappers {
         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);
+    mapSelectFields = (table, fields, aliases) => {
+        const lookup = selectFieldAliases(table, fields, aliases);
+        return fields.map((field, i) => this.mapSelectField(field, lookup[i]));
+    };
+    mapSelectField = (field, alias) => {
+        if (asIndexOf(field) >= 0)
+            throw new DatasourceError(`Select field "${field}" must be a path`);
+        const functionCall = functionOf(field);
+        const mapped = functionCall === undefined ? this.map(field) : `${functionCall.name}(${this.map(functionCall.inner)})`;
+        return applySelectFieldAlias(mapped, alias);
     };
 }
-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/index.d.ts

@@ -10,7 +10,7 @@ export type { DatasourceOptions } from "./DatasourceOptions.js";
 export { DatasourceFactory } from "./DatasourceFactory.js";
 export { ProviderCatalog } from "./ProviderCatalog.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 { ICreateTableStatement, ICreateIndexStatement, IDropTableStatement, IAlterTableStatement, AlterAction, IDropIndexStatement, IDropTriggerStatement, ICreateTriggerStatement, IIdentityInsertStatement, ICreateCreateStoredProcedureStatement, ICreateReadStoredProcedureStatement, ICreateNestedReadStoredProcedureStatement, NestedWhereArgument, 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";
@@ -52,7 +52,14 @@ export { RepositoryTreeNode } from "./RepositoryTreeNode.js";
 export { CRUDRepository } from "./CRUDRepository.js";
 export { ReadonlyRepositoryBuilder } from "./ReadonlyRepositoryBuilder.js";
 export { CRUDRepositoryBuilder } from "./CRUDRepositoryBuilder.js";
+export { RepositoryBuilderOptionsFactory } from "./RepositoryBuilderOptionsFactory.js";
 export { StatementMappers } from "./StatementMappers.js";
+export { NestedSelectBuilder } from "./NestedSelectBuilder.js";
+export type { NestedSelectBuilderOptions } from "./NestedSelectBuilderOptions.js";
+export type { NestedSelectRelation } from "./NestedSelectRelation.js";
+export type { NestedSelectRelationKind } from "./NestedSelectRelationKind.js";
+export type { NestedSelectStatement } from "./NestedSelectStatement.js";
+export type { NestedSelectType } from "./NestedSelectType.js";
 export { ReadonlyRepositoryStatements } from "./ReadonlyRepositoryStatements.js";
 export { CRUDRepositoryStatements } from "./CRUDRepositoryStatements.js";
 export type { BuiltRepository } from "./BuiltRepository.js";
@@ -67,7 +74,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, 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 { ArrayExpression, CheckConstraint, ColumnDefault, Condition, ConditionRenderer, ExpressionRenderer, CreateIndexStatement, CreateTableStatement, CreateTableStatementTextRenderer, CreateIndexStatementTextRenderer, DropTableStatement, DropTableStatementTextRenderer, AlterTableStatement, AlterTableStatementTextRenderer, DropIndexStatement, DropIndexStatementTextRenderer, DropTriggerStatement, DropTriggerStatementTextRenderer, CreateTriggerStatement, CreateTriggerStatementTextRenderer, IdentityInsertStatement, IdentityInsertStatementTextRenderer, CreateCreateStoredProcedureStatement, CreateReadStoredProcedureStatement, CreateNestedReadStoredProcedureStatement, CreateUpdateStoredProcedureStatement, CreateDeleteStoredProcedureStatement, CreateBulkCreateStoredProcedureStatement, CreateBulkUpdateStoredProcedureStatement, CreateBulkDeleteStoredProcedureStatement, CreateCreateStoredProcedureStatementTextRenderer, CreateReadStoredProcedureStatementTextRenderer, CreateNestedReadStoredProcedureStatementTextRenderer, 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";

package/dist/index.js

@@ -29,7 +29,9 @@ export { RepositoryTreeNode } from "./RepositoryTreeNode.js";
 export { CRUDRepository } from "./CRUDRepository.js";
 export { ReadonlyRepositoryBuilder } from "./ReadonlyRepositoryBuilder.js";
 export { CRUDRepositoryBuilder } from "./CRUDRepositoryBuilder.js";
+export { RepositoryBuilderOptionsFactory } from "./RepositoryBuilderOptionsFactory.js";
 export { StatementMappers } from "./StatementMappers.js";
+export { NestedSelectBuilder } from "./NestedSelectBuilder.js";
 export { ReadonlyRepositoryStatements } from "./ReadonlyRepositoryStatements.js";
 export { CRUDRepositoryStatements } from "./CRUDRepositoryStatements.js";
 export { createCRUDRepositoryOptions } from "./createCRUDRepositoryOptions.js";
@@ -37,7 +39,7 @@ export { createReadonlyRepositoryMappingOptions } from "./createReadonlyReposito
 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 { ArrayExpression, CheckConstraint, ColumnDefault, Condition, ConditionRenderer, ExpressionRenderer, CreateIndexStatement, CreateTableStatement, CreateTableStatementTextRenderer, CreateIndexStatementTextRenderer, DropTableStatement, DropTableStatementTextRenderer, AlterTableStatement, AlterTableStatementTextRenderer, DropIndexStatement, DropIndexStatementTextRenderer, DropTriggerStatement, DropTriggerStatementTextRenderer, CreateTriggerStatement, CreateTriggerStatementTextRenderer, IdentityInsertStatement, IdentityInsertStatementTextRenderer, CreateCreateStoredProcedureStatement, CreateReadStoredProcedureStatement, CreateNestedReadStoredProcedureStatement, CreateUpdateStoredProcedureStatement, CreateDeleteStoredProcedureStatement, CreateBulkCreateStoredProcedureStatement, CreateBulkUpdateStoredProcedureStatement, CreateBulkDeleteStoredProcedureStatement, CreateCreateStoredProcedureStatementTextRenderer, CreateReadStoredProcedureStatementTextRenderer, CreateNestedReadStoredProcedureStatementTextRenderer, 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";

package/dist/statements/Aggregate.d.ts

@@ -1,6 +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;
+    count: (column: string) => string;
+    sum: (column: string) => string;
+    min: (column: string) => string;
+    max: (column: string) => string;
 };

package/dist/statements/Aggregate.js

@@ -1,7 +1,7 @@
-const fragment = (op, column, alias) => alias === undefined ? `${op}(${column})` : `${op}(${column}) AS ${alias}`;
+const fragment = (op, column) => `${op}(${column})`;
 export const Aggregate = {
-    count: (column, alias) => fragment("COUNT", column, alias),
-    sum: (column, alias) => fragment("SUM", column, alias),
-    min: (column, alias) => fragment("MIN", column, alias),
-    max: (column, alias) => fragment("MAX", column, alias),
+    count: (column) => fragment("COUNT", column),
+    sum: (column) => fragment("SUM", column),
+    min: (column) => fragment("MIN", column),
+    max: (column) => fragment("MAX", column),
 };

package/dist/statements/CreateNestedReadStoredProcedureStatement.d.ts

@@ -0,0 +1,14 @@
+import type { NestedSelectStatement } from "../NestedSelectStatement.js";
+import type { ICreateNestedReadStoredProcedureStatement } from "./ICreateNestedReadStoredProcedureStatement.js";
+import type { IStatementVisitor } from "./IStatementVisitor.js";
+import type { NestedWhereArgument } from "./NestedWhereArgument.js";
+import { SelectStatement } from "./SelectStatement.js";
+export declare class CreateNestedReadStoredProcedureStatement implements ICreateNestedReadStoredProcedureStatement {
+    readonly name: string;
+    readonly nested: NestedSelectStatement;
+    readonly arguments: readonly NestedWhereArgument[];
+    constructor(name: string, nested: NestedSelectStatement, args: readonly NestedWhereArgument[]);
+    get select(): SelectStatement;
+    accept: (visitor: IStatementVisitor) => string;
+    static withArguments(select: SelectStatement, arguments_: readonly NestedWhereArgument[]): SelectStatement;
+}

package/dist/statements/CreateNestedReadStoredProcedureStatement.js

@@ -0,0 +1,37 @@
+import { Operator } from "./Operator.js";
+import { Identifier } from "./Identifier.js";
+import { SelectStatement } from "./SelectStatement.js";
+import { Where } from "./Where.js";
+export class CreateNestedReadStoredProcedureStatement {
+    name;
+    nested;
+    arguments;
+    constructor(name, nested, args) {
+        this.name = name;
+        this.nested = nested;
+        this.arguments = args;
+    }
+    get select() {
+        return CreateNestedReadStoredProcedureStatement.withArguments(this.nested.select, this.arguments);
+    }
+    accept = (visitor) => visitor.visit(this);
+    static withArguments(select, arguments_) {
+        const where = arguments_.reduce((clause, argument) => {
+            const equals = new Operator.Equals(new Identifier(argument.path), new Identifier(argument.parameter.name));
+            return clause instanceof Where ? new Where(new Operator.And(clause.condition, equals)) : new Where(equals);
+        }, select.where);
+        return new SelectStatement({
+            distinct: select.distinct,
+            table: select.table,
+            fields: select.fields,
+            aliases: select.aliases,
+            joins: select.joins,
+            where,
+            groupBy: select.groupBy,
+            having: select.having,
+            orderBy: select.orderBy,
+            limit: select.limit,
+            offset: select.offset,
+        });
+    }
+}

package/dist/statements/CreateNestedReadStoredProcedureStatementTextRenderer.d.ts

@@ -0,0 +1,4 @@
+import type { CreateNestedReadStoredProcedureStatement } from "./CreateNestedReadStoredProcedureStatement.js";
+export declare class CreateNestedReadStoredProcedureStatementTextRenderer {
+    render(_statement: CreateNestedReadStoredProcedureStatement): string;
+}

package/dist/statements/CreateNestedReadStoredProcedureStatementTextRenderer.js

@@ -0,0 +1,5 @@
+export class CreateNestedReadStoredProcedureStatementTextRenderer {
+    render(_statement) {
+        return "";
+    }
+}

package/dist/statements/ICreateNestedReadStoredProcedureStatement.d.ts

@@ -0,0 +1,8 @@
+import type { NestedSelectStatement } from "../NestedSelectStatement.js";
+import type { IStatement } from "./IStatement.js";
+import type { NestedWhereArgument } from "./NestedWhereArgument.js";
+export interface ICreateNestedReadStoredProcedureStatement extends IStatement {
+    readonly name: string;
+    readonly nested: NestedSelectStatement;
+    readonly arguments: readonly NestedWhereArgument[];
+}

package/dist/statements/ICreateNestedReadStoredProcedureStatement.js

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

package/dist/statements/IStatementVisitor.d.ts

@@ -10,6 +10,7 @@ import type { DropIndexStatement } from "./DropIndexStatement.js";
 import type { DropRoutineStatement } from "./DropRoutineStatement.js";
 import type { CreateCreateStoredProcedureStatement } from "./CreateCreateStoredProcedureStatement.js";
 import type { CreateReadStoredProcedureStatement } from "./CreateReadStoredProcedureStatement.js";
+import type { CreateNestedReadStoredProcedureStatement } from "./CreateNestedReadStoredProcedureStatement.js";
 import type { CreateUpdateStoredProcedureStatement } from "./CreateUpdateStoredProcedureStatement.js";
 import type { CreateDeleteStoredProcedureStatement } from "./CreateDeleteStoredProcedureStatement.js";
 import type { CreateBulkCreateStoredProcedureStatement } from "./CreateBulkCreateStoredProcedureStatement.js";
@@ -46,6 +47,7 @@ export interface IStatementVisitor {
     visit(statement: DropRoutineStatement): string;
     visit(statement: CreateCreateStoredProcedureStatement): string;
     visit(statement: CreateReadStoredProcedureStatement): string;
+    visit(statement: CreateNestedReadStoredProcedureStatement): string;
     visit(statement: CreateUpdateStoredProcedureStatement): string;
     visit(statement: CreateDeleteStoredProcedureStatement): string;
     visit(statement: CreateBulkCreateStoredProcedureStatement): string;

package/dist/statements/NestedWhereArgument.d.ts

@@ -0,0 +1,5 @@
+import type { RoutineParameter } from "./RoutineParameter.js";
+export type NestedWhereArgument = {
+    path: string;
+    parameter: RoutineParameter;
+};

package/dist/statements/NestedWhereArgument.js

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

package/dist/statements/SelectStatement.d.ts

@@ -9,6 +9,7 @@ export declare class SelectStatement implements ISelectStatement {
     readonly distinct: boolean;
     readonly table?: string;
     readonly fields: string[];
+    readonly aliases: (string | undefined)[];
     readonly joins: Join[];
     readonly groupBy: string[];
     readonly having?: IWhere;

package/dist/statements/SelectStatement.js

@@ -3,6 +3,7 @@ export class SelectStatement {
     distinct;
     table;
     fields;
+    aliases;
     joins;
     groupBy;
     having;
@@ -14,6 +15,7 @@ export class SelectStatement {
         this.distinct = options.distinct ?? false;
         this.table = options.table;
         this.fields = options.fields ?? [];
+        this.aliases = options.aliases ?? [];
         this.joins = options.joins ?? [];
         this.groupBy = options.groupBy ?? [];
         this.having = options.having;

package/dist/statements/SelectStatementOptions.d.ts

@@ -4,6 +4,7 @@ import type { OrderBy } from "./OrderBy.js";
 export type SelectStatementOptions = {
     table?: string;
     fields?: string[];
+    aliases?: (string | undefined)[];
     distinct?: boolean;
     where?: IWhere;
     joins?: Join[];

package/dist/statements/SelectStatementTextRenderer.js

@@ -1,4 +1,5 @@
 import { orderText } from "./OrderBy.js";
+import { applySelectFieldAlias } from "../SelectFieldAliases.js";
 import { Where } from "./Where.js";
 export class SelectStatementTextRenderer {
     text;
@@ -6,7 +7,11 @@ export class SelectStatementTextRenderer {
         this.text = text;
     }
     render(statement) {
-        return `SELECT ${statement.distinct ? "DISTINCT " : ""}${statement.fields.length === 0 ? "*" : statement.fields.join(", ")} FROM ${statement.table}${this.joinSql(statement.joins)}${this.whereSql(statement.where)}${this.groupSql(statement.groupBy)}${this.havingSql(statement.having)}${this.orderSql(statement.orderBy)}${this.limit(statement.limit)}${this.offset(statement.offset)}`;
+        return `SELECT ${statement.distinct ? "DISTINCT " : ""}${statement.fields.length === 0
+            ? "*"
+            : statement.fields
+                .map((field, i) => applySelectFieldAlias(field, statement.aliases[i]))
+                .join(", ")} FROM ${statement.table}${this.joinSql(statement.joins)}${this.whereSql(statement.where)}${this.groupSql(statement.groupBy)}${this.havingSql(statement.having)}${this.orderSql(statement.orderBy)}${this.limit(statement.limit)}${this.offset(statement.offset)}`;
     }
     whereSql(where) {
         return where ? ` WHERE ${this.text.render(where)}` : "";

package/dist/statements/StatementRenderer.d.ts

@@ -11,6 +11,7 @@ import { DropIndexStatement } from "./DropIndexStatement.js";
 import { DropRoutineStatement } from "./DropRoutineStatement.js";
 import { CreateCreateStoredProcedureStatement } from "./CreateCreateStoredProcedureStatement.js";
 import { CreateReadStoredProcedureStatement } from "./CreateReadStoredProcedureStatement.js";
+import { CreateNestedReadStoredProcedureStatement } from "./CreateNestedReadStoredProcedureStatement.js";
 import { CreateUpdateStoredProcedureStatement } from "./CreateUpdateStoredProcedureStatement.js";
 import { CreateDeleteStoredProcedureStatement } from "./CreateDeleteStoredProcedureStatement.js";
 import { CreateBulkCreateStoredProcedureStatement } from "./CreateBulkCreateStoredProcedureStatement.js";
@@ -50,6 +51,7 @@ export declare class StatementRenderer implements IStatementVisitor {
     visit(statement: DropRoutineStatement): string;
     visit(statement: CreateCreateStoredProcedureStatement): string;
     visit(statement: CreateReadStoredProcedureStatement): string;
+    visit(statement: CreateNestedReadStoredProcedureStatement): string;
     visit(statement: CreateUpdateStoredProcedureStatement): string;
     visit(statement: CreateDeleteStoredProcedureStatement): string;
     visit(statement: CreateBulkCreateStoredProcedureStatement): string;
@@ -76,6 +78,7 @@ export declare class StatementRenderer implements IStatementVisitor {
     protected visitDropRoutine(statement: DropRoutineStatement): string;
     protected visitCreateCreateStoredProcedureStatement(statement: CreateCreateStoredProcedureStatement): string;
     protected visitCreateReadStoredProcedureStatement(statement: CreateReadStoredProcedureStatement): string;
+    protected visitCreateNestedReadStoredProcedureStatement(statement: CreateNestedReadStoredProcedureStatement): string;
     protected visitCreateUpdateStoredProcedureStatement(statement: CreateUpdateStoredProcedureStatement): string;
     protected visitCreateDeleteStoredProcedureStatement(statement: CreateDeleteStoredProcedureStatement): string;
     protected visitCreateBulkCreateStoredProcedureStatement(statement: CreateBulkCreateStoredProcedureStatement): string;

package/dist/statements/StatementRenderer.js

@@ -10,6 +10,7 @@ import { DropIndexStatementTextRenderer } from "./DropIndexStatementTextRenderer
 import { DropRoutineStatementTextRenderer } from "./DropRoutineStatementTextRenderer.js";
 import { CreateCreateStoredProcedureStatementTextRenderer } from "./CreateCreateStoredProcedureStatementTextRenderer.js";
 import { CreateReadStoredProcedureStatementTextRenderer } from "./CreateReadStoredProcedureStatementTextRenderer.js";
+import { CreateNestedReadStoredProcedureStatementTextRenderer } from "./CreateNestedReadStoredProcedureStatementTextRenderer.js";
 import { CreateUpdateStoredProcedureStatementTextRenderer } from "./CreateUpdateStoredProcedureStatementTextRenderer.js";
 import { CreateDeleteStoredProcedureStatementTextRenderer } from "./CreateDeleteStoredProcedureStatementTextRenderer.js";
 import { CreateBulkCreateStoredProcedureStatementTextRenderer } from "./CreateBulkCreateStoredProcedureStatementTextRenderer.js";
@@ -51,6 +52,7 @@ export class StatementRenderer {
             DropRoutineStatement: () => this.visitDropRoutine(statement),
             CreateCreateStoredProcedureStatement: () => this.visitCreateCreateStoredProcedureStatement(statement),
             CreateReadStoredProcedureStatement: () => this.visitCreateReadStoredProcedureStatement(statement),
+            CreateNestedReadStoredProcedureStatement: () => this.visitCreateNestedReadStoredProcedureStatement(statement),
             CreateUpdateStoredProcedureStatement: () => this.visitCreateUpdateStoredProcedureStatement(statement),
             CreateDeleteStoredProcedureStatement: () => this.visitCreateDeleteStoredProcedureStatement(statement),
             CreateBulkCreateStoredProcedureStatement: () => this.visitCreateBulkCreateStoredProcedureStatement(statement),
@@ -122,6 +124,9 @@ export class StatementRenderer {
     visitCreateReadStoredProcedureStatement(statement) {
         return new CreateReadStoredProcedureStatementTextRenderer().render(statement);
     }
+    visitCreateNestedReadStoredProcedureStatement(statement) {
+        return new CreateNestedReadStoredProcedureStatementTextRenderer().render(statement);
+    }
     visitCreateUpdateStoredProcedureStatement(statement) {
         return new CreateUpdateStoredProcedureStatementTextRenderer().render(statement);
     }

package/dist/statements/Where.js

@@ -56,6 +56,7 @@ const rewriteQuery = (query, column, value) => query.table === undefined
         distinct: query.distinct,
         table: query.table,
         fields: query.fields,
+        aliases: query.aliases,
         where: rewriteWhere(query.where, column, value),
         joins: query.joins.map((join) => join.on ? { ...join, on: rewrite(join.on, column, value) } : join),
         groupBy: query.groupBy,

package/dist/statements/index.d.ts

@@ -23,6 +23,8 @@ export type { IIdentityInsertStatement } from "./IIdentityInsertStatement.js";
 export type { IDropRoutineStatement } from "./IDropRoutineStatement.js";
 export type { ICreateCreateStoredProcedureStatement } from "./ICreateCreateStoredProcedureStatement.js";
 export type { ICreateReadStoredProcedureStatement } from "./ICreateReadStoredProcedureStatement.js";
+export type { ICreateNestedReadStoredProcedureStatement } from "./ICreateNestedReadStoredProcedureStatement.js";
+export type { NestedWhereArgument } from "./NestedWhereArgument.js";
 export type { ICreateUpdateStoredProcedureStatement } from "./ICreateUpdateStoredProcedureStatement.js";
 export type { ICreateDeleteStoredProcedureStatement } from "./ICreateDeleteStoredProcedureStatement.js";
 export type { ICreateBulkCreateStoredProcedureStatement } from "./ICreateBulkCreateStoredProcedureStatement.js";
@@ -90,6 +92,8 @@ export { CreateCreateStoredProcedureStatement } from "./CreateCreateStoredProced
 export { CreateCreateStoredProcedureStatementTextRenderer } from "./CreateCreateStoredProcedureStatementTextRenderer.js";
 export { CreateReadStoredProcedureStatement } from "./CreateReadStoredProcedureStatement.js";
 export { CreateReadStoredProcedureStatementTextRenderer } from "./CreateReadStoredProcedureStatementTextRenderer.js";
+export { CreateNestedReadStoredProcedureStatement } from "./CreateNestedReadStoredProcedureStatement.js";
+export { CreateNestedReadStoredProcedureStatementTextRenderer } from "./CreateNestedReadStoredProcedureStatementTextRenderer.js";
 export { CreateUpdateStoredProcedureStatement } from "./CreateUpdateStoredProcedureStatement.js";
 export { CreateUpdateStoredProcedureStatementTextRenderer } from "./CreateUpdateStoredProcedureStatementTextRenderer.js";
 export { CreateDeleteStoredProcedureStatement } from "./CreateDeleteStoredProcedureStatement.js";

package/dist/statements/index.js

@@ -51,6 +51,8 @@ export { CreateCreateStoredProcedureStatement } from "./CreateCreateStoredProced
 export { CreateCreateStoredProcedureStatementTextRenderer } from "./CreateCreateStoredProcedureStatementTextRenderer.js";
 export { CreateReadStoredProcedureStatement } from "./CreateReadStoredProcedureStatement.js";
 export { CreateReadStoredProcedureStatementTextRenderer } from "./CreateReadStoredProcedureStatementTextRenderer.js";
+export { CreateNestedReadStoredProcedureStatement } from "./CreateNestedReadStoredProcedureStatement.js";
+export { CreateNestedReadStoredProcedureStatementTextRenderer } from "./CreateNestedReadStoredProcedureStatementTextRenderer.js";
 export { CreateUpdateStoredProcedureStatement } from "./CreateUpdateStoredProcedureStatement.js";
 export { CreateUpdateStoredProcedureStatementTextRenderer } from "./CreateUpdateStoredProcedureStatementTextRenderer.js";
 export { CreateDeleteStoredProcedureStatement } from "./CreateDeleteStoredProcedureStatement.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deterministic-code/datasources",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.js",