@deterministic-code/datasources 0.1.29 → 0.1.35

package/dist/BatchCommandIBulkWriteStrategy.js

@@ -89,7 +89,7 @@ export class BatchCommandIBulkWriteStrategy {
     };
     mappedUpdate = (item) => {
         const record = this.reverse(item);
-        const fields = this.fields(record, (col) => listed(this.options.updateProperties, col, !this.ids.includes(col)));
+        const fields = this.fields(record, (col) => listed(this.options.updateProperties, col, !this.ids.includes(col)), false);
         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));
@@ -102,7 +102,7 @@ export class BatchCommandIBulkWriteStrategy {
     };
     updateCommand = (item, byWhere) => {
         const record = this.reverse(item);
-        const fields = this.fields(record, (col) => listed(this.options.updateProperties, col, !this.ids.includes(col)));
+        const fields = this.fields(record, (col) => listed(this.options.updateProperties, col, !this.ids.includes(col)), false);
         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));
@@ -135,8 +135,8 @@ export class BatchCommandIBulkWriteStrategy {
             columns.includes(key) ||
             (map !== undefined && columns.some((name) => map.map(name) === key)));
     };
-    fields = (record, include) => Object.entries(record)
-        .filter(([key, value]) => include(key) && this.writable(key) && value !== null && value !== undefined)
+    fields = (record, include, omitNull = true) => Object.entries(record)
+        .filter(([key, value]) => include(key) && this.writable(key) && value !== undefined && (!omitNull || value !== null))
         .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

@@ -15,6 +15,7 @@ export declare class CRUDRepository<T = Cells> extends ReadonlyRepository<T> imp
     private readonly createProperties?;
     private readonly updateProperties?;
     protected createZeros?: Cells;
+    private readonly schema;
     private readonly crudStatements;
     private readonly tree;
     private readonly write;
@@ -41,4 +42,5 @@ export declare class CRUDRepository<T = Cells> extends ReadonlyRepository<T> imp
     private reverseConvert;
     private idWhere;
     protected enrichmentInto: (name: string) => boolean;
+    private enrichmentSource;
 }

package/dist/CRUDRepository.js

@@ -11,14 +11,31 @@ import { DefaultWriteEnrichmentStrategy } from "./DefaultWriteEnrichmentStrategy
 import { UnitOfWorkTransaction } from "./UnitOfWorkTransaction.js";
 import { RepositoryTree } from "./RepositoryTree.js";
 import { RepositoryTreeNode } from "./RepositoryTreeNode.js";
+import { Schema } from "./Schema.js";
+import { SchemaDefault } from "./SchemaDefault.js";
 const assigned = (value) => value !== null && value !== "" && value !== 0 && value !== 0n;
 const listed = (list, col, fallback) => list === undefined ? fallback : list.includes(col);
+const languageZero = (value) => value === "" || value === false;
+const applyEmptyDefaults = (record, schema, ids, properties, fillMissing, skip) => {
+    const filled = { ...record };
+    for (const [name, column] of Object.entries(schema.columns)) {
+        if (ids.includes(name) || !listed(properties, name, true) || column.hasDefault || skip(name))
+            continue;
+        const zero = SchemaDefault.of(column);
+        if (filled[name] === "")
+            filled[name] = zero;
+        else if (fillMissing && filled[name] === undefined && languageZero(zero))
+            filled[name] = zero;
+    }
+    return filled;
+};
+const zerosFromSchema = (schema, ids, createProperties, skip) => applyEmptyDefaults({}, schema, ids, createProperties, true, skip);
 const writable = (key, columns, column) => columns.length === 0 || columns.includes(key) || columns.some((name) => column(name) === key);
-const fieldsOf = (record, include, extras, cell, enrichmentInto, columns, column) => Object.entries(record)
+const fieldsOf = (record, include, extras, cell, enrichmentInto, columns, column, omitNull = true) => Object.entries(record)
     .filter(([key, value]) => include(key) &&
     (extras.has(key) || (writable(key, columns, column) && !enrichmentInto(key))) &&
-    value !== null &&
-    value !== undefined)
+    value !== undefined &&
+    (!omitNull || value !== null))
     .sort(([left], [right]) => left.localeCompare(right))
     .map(([name, value]) => ({ name, value: cell(name, value, true) }));
 const isCells = (id) => typeof id === "object" && id !== null;
@@ -38,6 +55,7 @@ export class CRUDRepository extends ReadonlyRepository {
     createProperties;
     updateProperties;
     createZeros;
+    schema;
     crudStatements;
     tree;
     write;
@@ -51,6 +69,7 @@ export class CRUDRepository extends ReadonlyRepository {
         this.ids = opened.built.ids;
         this.createProperties = options.createProperties;
         this.updateProperties = options.updateProperties;
+        this.schema = options.schema ?? new Schema({});
         this.crudStatements = opened.statements;
         this.tree = new RepositoryTree(new RepositoryTreeNode(this, ""));
         this.write = options.write ?? new DefaultWriteEnrichmentStrategy();
@@ -155,8 +174,8 @@ export class CRUDRepository extends ReadonlyRepository {
     idValue = (item) => scalarOf(item[this.ids[0]]);
     save = async (item, byWhere) => {
         const extras = lookupKeys(item);
-        const record = this.reverseConvert(item);
-        const fields = fieldsOf(record, (col) => extras.has(col) || listed(this.updateProperties, col, !this.ids.includes(col)), extras, this.cell, this.enrichmentInto, this.crudStatements.readColumns, this.column);
+        const record = applyEmptyDefaults(this.reverseConvert(item), this.schema, this.ids, this.updateProperties, false, (name) => this.enrichmentSource(name));
+        const fields = fieldsOf(record, (col) => extras.has(col) || listed(this.updateProperties, col, !this.ids.includes(col)), extras, this.cell, this.enrichmentInto, this.crudStatements.readColumns, this.column, false);
         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));
@@ -182,7 +201,14 @@ export class CRUDRepository extends ReadonlyRepository {
             throw new DatasourceError("Composite id requires a row keyed by each Id column");
         return this.idWhere({ [this.ids[0]]: id });
     };
-    fillCreateZeros = (record) => this.createZeros === undefined ? record : { ...this.createZeros, ...record };
+    fillCreateZeros = (record) => {
+        const skip = (name) => this.enrichmentSource(name);
+        const zeros = this.createZeros !== undefined && Object.keys(this.createZeros).length > 0
+            ? this.createZeros
+            : zerosFromSchema(this.schema, this.ids, this.createProperties, skip);
+        const filled = Object.keys(zeros).length === 0 ? { ...record } : { ...zeros, ...record };
+        return applyEmptyDefaults(filled, this.schema, this.ids, this.createProperties, false, skip);
+    };
     reverseConvert = (item) => {
         const row = this.objectConverter.reverseConvert(item);
         const converted = this.rowConverter ? this.rowConverter.reverseConvert(row) : row;
@@ -200,6 +226,7 @@ export class CRUDRepository extends ReadonlyRepository {
             : parts.reduce((left, right) => new Operator.And(left, right)));
     };
     enrichmentInto = (name) => enrichmentsOf(this).some((entry) => entry.enrichment.destinationProperty === name);
+    enrichmentSource = (name) => enrichmentsOf(this).some((entry) => entry.enrichment.sourceProperty === name);
 }
 const writerOf = (via) => "create" in via && typeof via.create === "function" ? via : undefined;
 const lastEnrichment = (host) => enrichmentsOf(host).at(-1);

package/dist/Datasource.js

@@ -49,7 +49,7 @@ export class Datasource {
         const built = createCRUDRepositoryOptions(type, this.driver.rowTypeConverters);
         const types = this.driver.rowTypeConverters;
         const schema = options?.schema ?? new Schema({});
-        const rows = options?.rowConverter ?? RowTypeConverter.from(this.driver.rowTypeConverters, schema.columns);
+        const rows = options?.rowConverter ?? RowTypeConverter.from(this.driver.rowTypeConverters, schema.types());
         return {
             ...(options ?? built),
             entity: options?.entity ?? built.entity,
@@ -63,7 +63,7 @@ export class Datasource {
         const built = createReadonlyRepositoryMappingOptions(type, this.driver.rowTypeConverters);
         const types = this.driver.rowTypeConverters;
         const schema = options?.schema ?? new Schema({});
-        const rows = options?.rowConverter ?? RowTypeConverter.from(this.driver.rowTypeConverters, schema.columns);
+        const rows = options?.rowConverter ?? RowTypeConverter.from(this.driver.rowTypeConverters, schema.types());
         return {
             ...(options ?? built),
             entity: options?.entity ?? built.entity,

package/dist/Schema.d.ts

@@ -1,4 +1,10 @@
+export type SchemaColumn = {
+    type: string;
+    nullable: boolean;
+    hasDefault: boolean;
+};
 export declare class Schema {
-    readonly columns: Readonly<Record<string, string>>;
-    constructor(columns: Readonly<Record<string, string>>);
+    readonly columns: Readonly<Record<string, SchemaColumn>>;
+    constructor(columns: Readonly<Record<string, SchemaColumn>>);
+    types: () => Record<string, string>;
 }

package/dist/Schema.js

@@ -3,4 +3,5 @@ export class Schema {
     constructor(columns) {
         this.columns = columns;
     }
+    types = () => Object.fromEntries(Object.entries(this.columns).map(([name, column]) => [name, column.type]));
 }

package/dist/SchemaDefault.d.ts

@@ -0,0 +1,5 @@
+import type { Cell } from "./converters/Cell.js";
+import type { SchemaColumn } from "./Schema.js";
+export declare const SchemaDefault: {
+    of: (column: SchemaColumn) => Cell;
+};

package/dist/SchemaDefault.js

@@ -0,0 +1,11 @@
+const required = {
+    string: "",
+    boolean: false,
+};
+export const SchemaDefault = {
+    of: (column) => column.nullable
+        ? null
+        : column.type.endsWith("integer")
+            ? 0
+            : (required[column.type] ?? null),
+};

package/dist/StatementMappers.js

@@ -1,5 +1,5 @@
 import { DatasourceError } from "./DatasourceError.js";
-import { applySelectFieldAlias, asIndexOf, functionOf, segments, selectFieldAliases } from "./SelectFieldAliases.js";
+import { applySelectFieldAlias, asIndexOf, functionOf, segments, selectFieldAliases } from "./statements/SelectFieldAliases.js";
 import { DeleteStatement } from "./statements/DeleteStatement.js";
 import { InsertStatement } from "./statements/InsertStatement.js";
 import { SelectInsertedIdStatement } from "./statements/SelectInsertedIdStatement.js";

package/dist/index.d.ts

@@ -54,12 +54,6 @@ 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";
@@ -74,7 +68,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, SqlSeedStatement, ForeignKeyStatement, 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 { ArrayExpression, CheckConstraint, ColumnDefault, Condition, ConditionRenderer, ExpressionRenderer, CreateIndexStatement, CreateTableStatement, CreateTableStatementTextRenderer, CreateIndexStatementTextRenderer, DropTableStatement, DropTableStatementTextRenderer, AlterTableStatement, AlterTableStatementTextRenderer, DropIndexStatement, DropIndexStatementTextRenderer, DropTriggerStatement, DropTriggerStatementTextRenderer, CreateTriggerStatement, CreateTriggerStatementTextRenderer, IdentityInsertStatement, IdentityInsertStatementTextRenderer, SqlSeedStatement, ForeignKeyStatement, 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, NestedSelectBuilder, StatementParser, StatementRenderer, StatementTextRenderer, StatementNaming, KeywordCasing, constraintNameOf, sqlProcedureStatementsOf, procedureNameOf, 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";
@@ -115,7 +109,7 @@ export { FlatToNestedMapper } from "./mappers/FlatToNestedMapper.js";
 export { ChangeCasingMapper } from "./mappers/ChangeCasingMapper.js";
 export { DictionaryMapper } from "./mappers/DictionaryMapper.js";
 export { DeterministicTypeMapper } from "./mappers/DeterministicTypeMapper.js";
-export { Schema } from "./Schema.js";
+export { Schema, type SchemaColumn } from "./Schema.js";
 export { IdentityMapper } from "./mappers/IdentityMapper.js";
 export { PluralizerMapper } from "./mappers/PluralizerMapper.js";
 export { TransformMapper } from "./mappers/TransformMapper.js";
@@ -124,7 +118,7 @@ export { RowTypeMapper } from "./mappers/RowTypeMapper.js";
 export { parametersToRecord } from "./parametersToRecord.js";
 export { ProviderNotImplementedError } from "./ProviderNotImplementedError.js";
 export { ProviderNotInstalledError } from "./ProviderNotInstalledError.js";
-export type { Column, JoinKind, SelectStatementOptions, ReferentialAction as ReferentialActionName, SortDirection } from "./statements/index.js";
+export type { Column, JoinKind, SelectStatementOptions, ReferentialAction as ReferentialActionName, SortDirection, ProcedureSource, ProcedureByGroup, NestedSelectBuilderOptions, NestedSelectRelation, NestedSelectRelationKind, NestedSelectStatement, NestedSelectType } from "./statements/index.js";
 export type { Field, Scalar } from "./builders/index.js";
 export { readerToAsyncIterable } from "./readerToAsyncIterable.js";
 export { StubCommand, StubConnection, StubDatasource, StubReader, StubRepository, StubTransaction, createStubDatasource, } from "./stubs/index.js";

package/dist/index.js

@@ -31,7 +31,6 @@ 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";
@@ -39,7 +38,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, SqlSeedStatement, ForeignKeyStatement, 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 { ArrayExpression, CheckConstraint, ColumnDefault, Condition, ConditionRenderer, ExpressionRenderer, CreateIndexStatement, CreateTableStatement, CreateTableStatementTextRenderer, CreateIndexStatementTextRenderer, DropTableStatement, DropTableStatementTextRenderer, AlterTableStatement, AlterTableStatementTextRenderer, DropIndexStatement, DropIndexStatementTextRenderer, DropTriggerStatement, DropTriggerStatementTextRenderer, CreateTriggerStatement, CreateTriggerStatementTextRenderer, IdentityInsertStatement, IdentityInsertStatementTextRenderer, SqlSeedStatement, ForeignKeyStatement, 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, NestedSelectBuilder, StatementParser, StatementRenderer, StatementTextRenderer, StatementNaming, KeywordCasing, constraintNameOf, sqlProcedureStatementsOf, procedureNameOf, 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/ConstraintName.d.ts

@@ -0,0 +1,2 @@
+import type { StatementNaming } from "./StatementNaming.js";
+export declare const constraintNameOf: (entity: string, naming: StatementNaming, ...parts: string[]) => string;

package/dist/statements/ConstraintName.js

@@ -0,0 +1,3 @@
+export const constraintNameOf = (entity, naming, ...parts) => naming.isVerbatim(entity)
+    ? [entity, ...parts].join("_")
+    : naming.letter(naming.convert([naming.physicalStem(entity), ...parts].join("_"), naming.constraintNameCasing));

package/dist/statements/CreateIndexStatement.d.ts

@@ -1,5 +1,6 @@
 import type { ICreateIndexStatement } from "./ICreateIndexStatement.js";
 import type { IStatementVisitor } from "./IStatementVisitor.js";
+import type { StatementNaming } from "./StatementNaming.js";
 export declare class CreateIndexStatement implements ICreateIndexStatement {
     readonly name: string;
     readonly table: string;
@@ -7,4 +8,5 @@ export declare class CreateIndexStatement implements ICreateIndexStatement {
     readonly unique: boolean;
     constructor(name: string, table: string, columns: string[], unique?: boolean);
     accept: (visitor: IStatementVisitor) => string;
+    static nameOf: (entity: string, naming: StatementNaming, ...parts: string[]) => string;
 }

package/dist/statements/CreateIndexStatement.js

@@ -1,3 +1,4 @@
+import { constraintNameOf } from "./ConstraintName.js";
 export class CreateIndexStatement {
     name;
     table;
@@ -10,4 +11,5 @@ export class CreateIndexStatement {
         this.unique = unique;
     }
     accept = (visitor) => visitor.visit(this);
+    static nameOf = (entity, naming, ...parts) => constraintNameOf(entity, naming, ...parts);
 }

package/dist/statements/CreateNestedReadStoredProcedureStatement.d.ts

@@ -1,4 +1,4 @@
-import type { NestedSelectStatement } from "../NestedSelectStatement.js";
+import type { NestedSelectStatement } from "./NestedSelectStatement.js";
 import type { ICreateNestedReadStoredProcedureStatement } from "./ICreateNestedReadStoredProcedureStatement.js";
 import type { IStatementVisitor } from "./IStatementVisitor.js";
 import type { NestedWhereArgument } from "./NestedWhereArgument.js";

package/dist/statements/CreateTableStatement.d.ts

@@ -2,10 +2,13 @@ import type { Column } from "./Column.js";
 import type { ICreateTableStatement } from "./ICreateTableStatement.js";
 import type { IStatementVisitor } from "./IStatementVisitor.js";
 import type { ITableConstraint } from "./ITableConstraint.js";
+import type { StatementNaming } from "./StatementNaming.js";
 export declare class CreateTableStatement implements ICreateTableStatement {
     readonly table: string;
     readonly columns: Column[];
     readonly constraints: ITableConstraint[];
     constructor(table: string, columns: Column[], constraints?: ITableConstraint[]);
     accept: (visitor: IStatementVisitor) => string;
+    static tableName: (entity: string, naming: StatementNaming) => string;
+    static columnName: (field: string, naming: StatementNaming) => string;
 }

package/dist/statements/CreateTableStatement.js

@@ -8,4 +8,8 @@ export class CreateTableStatement {
         this.constraints = constraints;
     }
     accept = (visitor) => visitor.visit(this);
+    static tableName = (entity, naming) => naming.isVerbatim(entity)
+        ? entity
+        : naming.letter(naming.convert(naming.physicalStem(entity), naming.tableNameCasing));
+    static columnName = (field, naming) => naming.isVerbatim(field) ? field : naming.convert(field, naming.fieldNameCasing);
 }

package/dist/statements/CreateTriggerStatement.d.ts

@@ -1,5 +1,6 @@
 import type { ICreateTriggerStatement } from "./ICreateTriggerStatement.js";
 import type { IStatementVisitor } from "./IStatementVisitor.js";
+import type { StatementNaming } from "./StatementNaming.js";
 export declare class CreateTriggerStatement implements ICreateTriggerStatement {
     readonly table: string;
     readonly name: string;
@@ -7,4 +8,5 @@ export declare class CreateTriggerStatement implements ICreateTriggerStatement {
     readonly keyColumn: string;
     constructor(table: string, name: string, updatedColumn: string, keyColumn: string);
     accept: (visitor: IStatementVisitor) => string;
+    static nameOf: (entity: string, naming: StatementNaming) => string;
 }

package/dist/statements/CreateTriggerStatement.js

@@ -10,4 +10,10 @@ export class CreateTriggerStatement {
         this.keyColumn = keyColumn;
     }
     accept = (visitor) => visitor.visit(this);
+    static nameOf = (entity, naming) => {
+        if (naming.isVerbatim(entity))
+            return `trg_${entity}_updated_at`;
+        const stem = naming.physicalStem(entity);
+        return naming.letter(naming.convert(`trg_${stem}_updated_at`, naming.triggerNameCasing));
+    };
 }

package/dist/statements/ForeignKey.d.ts

@@ -1,4 +1,5 @@
 import type { ITableConstraint } from "./ITableConstraint.js";
+import type { StatementNaming } from "./StatementNaming.js";
 export declare const ReferentialAction: {
     readonly Cascade: "cascade";
     readonly SetNull: "setNull";
@@ -16,4 +17,5 @@ export declare class ForeignKey implements ITableConstraint {
     readonly onUpdate?: ReferentialAction | undefined;
     readonly kind: "foreignKey";
     constructor(name: string, columns: string[], referencesTable: string, referencesColumns: string[], onDelete?: ReferentialAction | undefined, onUpdate?: ReferentialAction | undefined);
+    static nameOf: (entity: string, naming: StatementNaming, ...parts: string[]) => string;
 }

package/dist/statements/ForeignKey.js

@@ -1,3 +1,4 @@
+import { constraintNameOf } from "./ConstraintName.js";
 export const ReferentialAction = {
     Cascade: "cascade",
     SetNull: "setNull",
@@ -21,4 +22,5 @@ export class ForeignKey {
         this.onDelete = onDelete;
         this.onUpdate = onUpdate;
     }
+    static nameOf = (entity, naming, ...parts) => constraintNameOf(entity, naming, ...parts);
 }

package/dist/statements/ForeignKeyStatement.d.ts

@@ -1,6 +1,7 @@
 import type { IForeignKeyStatement } from "./IForeignKeyStatement.js";
 import type { IStatementVisitor } from "./IStatementVisitor.js";
 import type { ReferentialAction } from "./ForeignKey.js";
+import type { StatementNaming } from "./StatementNaming.js";
 export declare class ForeignKeyStatement implements IForeignKeyStatement {
     readonly table: string;
     readonly name: string;
@@ -12,4 +13,5 @@ export declare class ForeignKeyStatement implements IForeignKeyStatement {
     readonly onUpdate?: ReferentialAction | undefined;
     constructor(table: string, name: string, columns: readonly string[], referencesTable: string, referencesColumns: readonly string[], kind?: "add" | "drop", onDelete?: ReferentialAction | undefined, onUpdate?: ReferentialAction | undefined);
     accept: (visitor: IStatementVisitor) => string;
+    static nameOf: (entity: string, naming: StatementNaming, ...parts: string[]) => string;
 }

package/dist/statements/ForeignKeyStatement.js

@@ -1,3 +1,4 @@
+import { constraintNameOf } from "./ConstraintName.js";
 export class ForeignKeyStatement {
     table;
     name;
@@ -18,4 +19,5 @@ export class ForeignKeyStatement {
         this.onUpdate = onUpdate;
     }
     accept = (visitor) => visitor.visit(this);
+    static nameOf = (entity, naming, ...parts) => constraintNameOf(entity, naming, ...parts);
 }

package/dist/statements/ICreateNestedReadStoredProcedureStatement.d.ts

@@ -1,4 +1,4 @@
-import type { NestedSelectStatement } from "../NestedSelectStatement.js";
+import type { NestedSelectStatement } from "./NestedSelectStatement.js";
 import type { IStatement } from "./IStatement.js";
 import type { NestedWhereArgument } from "./NestedWhereArgument.js";
 export interface ICreateNestedReadStoredProcedureStatement extends IStatement {

package/dist/statements/KeywordCasing.d.ts

@@ -0,0 +1,5 @@
+export declare const KeywordCasing: {
+    readonly Upper: "upper";
+    readonly Lower: "lower";
+};
+export type KeywordCasing = (typeof KeywordCasing)[keyof typeof KeywordCasing];

package/dist/statements/KeywordCasing.js

@@ -0,0 +1,4 @@
+export const KeywordCasing = {
+    Upper: "upper",
+    Lower: "lower",
+};

package/dist/statements/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/statements/NestedSelectBuilder.js

@@ -0,0 +1,63 @@
+import { selectFieldAliases } from "./SelectFieldAliases.js";
+import { Join } from "./Join.js";
+import { SelectStatement } from "./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/statements/NestedSelectBuilderOptions.d.ts

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

package/dist/statements/NestedSelectBuilderOptions.js

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

package/dist/statements/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/statements/NestedSelectRelation.js

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

package/dist/statements/NestedSelectRelationKind.d.ts

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

package/dist/statements/NestedSelectRelationKind.js

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

package/dist/statements/NestedSelectStatement.d.ts

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

package/dist/statements/NestedSelectStatement.js

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

package/dist/statements/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/statements/NestedSelectType.js

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

package/dist/statements/PrimaryKey.d.ts

@@ -1,7 +1,9 @@
 import type { ITableConstraint } from "./ITableConstraint.js";
+import type { StatementNaming } from "./StatementNaming.js";
 export declare class PrimaryKey implements ITableConstraint {
     readonly name: string;
     readonly columns: string[];
     readonly kind: "primaryKey";
     constructor(name: string, columns: string[]);
+    static nameOf: (entity: string, naming: StatementNaming, ...parts: string[]) => string;
 }

package/dist/statements/PrimaryKey.js

@@ -1,3 +1,4 @@
+import { constraintNameOf } from "./ConstraintName.js";
 export class PrimaryKey {
     name;
     columns;
@@ -6,4 +7,5 @@ export class PrimaryKey {
         this.name = name;
         this.columns = columns;
     }
+    static nameOf = (entity, naming, ...parts) => constraintNameOf(entity, naming, ...parts);
 }

package/dist/statements/ProcedureSource.d.ts

@@ -0,0 +1,23 @@
+import type { RoutineParameter } from "./RoutineParameter.js";
+export type ProcedureByGroup = {
+    logical: readonly string[];
+    columns: readonly string[];
+    parameters: readonly RoutineParameter[];
+    updateParameters: readonly RoutineParameter[];
+};
+export type ProcedureSource = {
+    plural: string;
+    table: string;
+    columns: readonly string[];
+    createParameters: readonly RoutineParameter[];
+    writable: readonly string[];
+    createColumns: readonly RoutineParameter[];
+    updateColumns: readonly RoutineParameter[];
+    typedColumns: readonly RoutineParameter[];
+    byGroups: readonly ProcedureByGroup[];
+    key: string;
+    keyType: string;
+    auditUpdated?: string;
+    generatedKey: boolean;
+    routineName: (stem: string) => string;
+};

package/dist/statements/ProcedureSource.js

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

package/dist/statements/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/statements/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/statements/SelectStatementTextRenderer.js

@@ -1,5 +1,5 @@
 import { orderText } from "./OrderBy.js";
-import { applySelectFieldAlias } from "../SelectFieldAliases.js";
+import { applySelectFieldAlias } from "./SelectFieldAliases.js";
 import { Where } from "./Where.js";
 export class SelectStatementTextRenderer {
     text;

package/dist/statements/SqlProcedureStatements.d.ts

@@ -0,0 +1,4 @@
+import type { IStatement } from "./IStatement.js";
+import type { ProcedureSource } from "./ProcedureSource.js";
+export declare const sqlProcedureStatementsOf: (source: ProcedureSource) => IStatement[];
+export declare const procedureNameOf: (statement: IStatement) => string;

package/dist/statements/SqlProcedureStatements.js

@@ -0,0 +1,34 @@
+import { CreateBulkCreateStoredProcedureStatement } from "./CreateBulkCreateStoredProcedureStatement.js";
+import { CreateBulkDeleteStoredProcedureStatement } from "./CreateBulkDeleteStoredProcedureStatement.js";
+import { CreateBulkUpdateStoredProcedureStatement } from "./CreateBulkUpdateStoredProcedureStatement.js";
+import { CreateCreateStoredProcedureStatement } from "./CreateCreateStoredProcedureStatement.js";
+import { CreateDeleteStoredProcedureStatement } from "./CreateDeleteStoredProcedureStatement.js";
+import { CreateReadStoredProcedureStatement } from "./CreateReadStoredProcedureStatement.js";
+import { CreateUpdateStoredProcedureStatement } from "./CreateUpdateStoredProcedureStatement.js";
+export const sqlProcedureStatementsOf = (source) => {
+    const name = (stem) => source.routineName(stem);
+    const plural = source.plural;
+    const payload = { name: "payload", type: "payload" };
+    const statements = [
+        new CreateCreateStoredProcedureStatement(name(`create_${plural}`), source.table, source.columns, source.createParameters, source.key, source.keyType, source.writable, source.generatedKey, source.auditUpdated),
+        new CreateReadStoredProcedureStatement(name(`read_${plural}`), source.table, source.columns, [], source.key, source.keyType, source.writable, [], source.generatedKey, source.auditUpdated),
+    ];
+    for (const group of source.byGroups) {
+        const suffix = `_by_${group.logical.join("_")}`;
+        statements.push(new CreateReadStoredProcedureStatement(name(`read_${plural}${suffix}`), source.table, source.columns, group.parameters, source.key, source.keyType, source.writable, group.columns, source.generatedKey, source.auditUpdated), new CreateUpdateStoredProcedureStatement(name(`update_${plural}${suffix}`), source.table, source.columns, group.updateParameters, source.key, source.keyType, source.writable, group.columns, source.generatedKey, source.auditUpdated), new CreateDeleteStoredProcedureStatement(name(`delete_${plural}${suffix}`), source.table, source.columns, group.parameters, source.key, source.keyType, source.writable, group.columns, source.generatedKey, source.auditUpdated));
+    }
+    statements.push(new CreateBulkCreateStoredProcedureStatement(name(`bulk_create_${plural}`), source.table, source.createColumns, payload, source.key, source.keyType), new CreateBulkUpdateStoredProcedureStatement(name(`bulk_update_${plural}`), source.table, source.updateColumns, payload, source.key, source.keyType), new CreateBulkDeleteStoredProcedureStatement(name(`bulk_delete_${plural}`), source.table, source.typedColumns, payload, source.key, source.keyType));
+    return statements;
+};
+export const procedureNameOf = (statement) => {
+    if (statement instanceof CreateCreateStoredProcedureStatement ||
+        statement instanceof CreateReadStoredProcedureStatement ||
+        statement instanceof CreateUpdateStoredProcedureStatement ||
+        statement instanceof CreateDeleteStoredProcedureStatement ||
+        statement instanceof CreateBulkCreateStoredProcedureStatement ||
+        statement instanceof CreateBulkUpdateStoredProcedureStatement ||
+        statement instanceof CreateBulkDeleteStoredProcedureStatement) {
+        return statement.name;
+    }
+    throw new Error("procedure statement has no name");
+};

package/dist/statements/StatementNaming.d.ts

@@ -0,0 +1,26 @@
+import { type Casing } from "../converters/ChangeCasingConverter.js";
+import { KeywordCasing } from "./KeywordCasing.js";
+export declare class StatementNaming {
+    readonly tableNameCasing: Casing;
+    readonly fieldNameCasing: Casing;
+    readonly constraintNameCasing: Casing;
+    readonly triggerNameCasing: Casing;
+    readonly keywordCasing: KeywordCasing;
+    readonly pluralizeTables: boolean;
+    readonly objects: "preserve" | "upper" | "lower";
+    static readonly sql: StatementNaming;
+    constructor(options?: {
+        tableNameCasing?: Casing;
+        fieldNameCasing?: Casing;
+        constraintNameCasing?: Casing;
+        triggerNameCasing?: Casing;
+        keywordCasing?: KeywordCasing;
+        pluralizeTables?: boolean;
+        objects?: "preserve" | "upper" | "lower";
+    });
+    isVerbatim: (mapping: string) => boolean;
+    physicalStem: (name: string) => string;
+    convert: (text: string, casing: Casing) => string;
+    letter: (text: string) => string;
+    keyword: (text: string) => string;
+}

package/dist/statements/StatementNaming.js

@@ -0,0 +1,64 @@
+import { ChangeCasingConverter } from "../converters/ChangeCasingConverter.js";
+import { PluralizerConverter } from "../converters/PluralizerConverter.js";
+import { KeywordCasing } from "./KeywordCasing.js";
+const snake = /^[a-z_][a-z0-9_]*$/;
+const pluralizer = new PluralizerConverter();
+export class StatementNaming {
+    tableNameCasing;
+    fieldNameCasing;
+    constraintNameCasing;
+    triggerNameCasing;
+    keywordCasing;
+    pluralizeTables;
+    objects;
+    static sql = new StatementNaming();
+    constructor(options = {}) {
+        this.tableNameCasing = options.tableNameCasing ?? "snakeCase";
+        this.fieldNameCasing = options.fieldNameCasing ?? "snakeCase";
+        this.constraintNameCasing = options.constraintNameCasing ?? "snakeCase";
+        this.triggerNameCasing = options.triggerNameCasing ?? "snakeCase";
+        this.keywordCasing = options.keywordCasing ?? KeywordCasing.Upper;
+        this.pluralizeTables = options.pluralizeTables ?? true;
+        this.objects = options.objects ?? "preserve";
+    }
+    isVerbatim = (mapping) => !snake.test(mapping);
+    physicalStem = (name) => this.isVerbatim(name) ? name : this.pluralizeTables ? lastToken(name) : name;
+    convert = (text, casing) => {
+        const words = identifierWords(text);
+        if (words.length === 0)
+            return text;
+        switch (casing) {
+            case "camelCase":
+                return words.map((word, i) => (i === 0 ? word : cap(word))).join("");
+            case "pascalCase":
+                return words.map(cap).join("");
+            case "snakeCase":
+                return words.join("_");
+            case "kebabCase":
+                return words.join("-");
+            default:
+                return new ChangeCasingConverter(casing).convert(text);
+        }
+    };
+    letter = (text) => this.objects === "upper"
+        ? text.toUpperCase()
+        : this.objects === "lower"
+            ? text.toLowerCase()
+            : text;
+    keyword = (text) => this.keywordCasing === KeywordCasing.Lower ? text.toLowerCase() : text.toUpperCase();
+}
+const identifierWords = (name) => name
+    .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+    .replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2")
+    .replace(/[_\-.]+/g, " ")
+    .trim()
+    .split(/\s+/)
+    .filter((word) => word.length > 0)
+    .map((word) => word.toLowerCase());
+const cap = (word) => word[0].toUpperCase() + word.slice(1);
+const lastToken = (name) => {
+    const at = name.lastIndexOf("_");
+    return at < 0
+        ? pluralizer.convert(name)
+        : `${name.slice(0, at + 1)}${pluralizer.convert(name.slice(at + 1))}`;
+};

package/dist/statements/StatementRenderer.d.ts

@@ -32,6 +32,7 @@ import { UpdateStatement } from "./UpdateStatement.js";
 export declare class StatementRenderer implements IStatementVisitor {
     protected readonly text: StatementTextRenderer;
     constructor(text: StatementTextRenderer);
+    procedures(_source: import("./ProcedureSource.js").ProcedureSource): import("./IStatement.js").IStatement[];
     visit(statement: SelectStatement): string;
     visit(statement: InsertStatement): string;
     visit(statement: UpdateStatement): string;

package/dist/statements/StatementRenderer.js

@@ -30,6 +30,9 @@ export class StatementRenderer {
     constructor(text) {
         this.text = text;
     }
+    procedures(_source) {
+        return [];
+    }
     visit(statement) {
         return ({
             SelectStatement: () => this.visitSelect(statement),

package/dist/statements/StatementTextRenderer.d.ts

@@ -4,11 +4,21 @@ import type { IStatement } from "./IStatement.js";
 import type { IStatementVisitor } from "./IStatementVisitor.js";
 import { ConditionRenderer } from "./ConditionRenderer.js";
 import { ExpressionRenderer } from "./ExpressionRenderer.js";
+import type { ProcedureSource } from "./ProcedureSource.js";
 import { StatementRenderer } from "./StatementRenderer.js";
+import { StatementNaming } from "./StatementNaming.js";
 export declare class StatementTextRenderer {
     protected readonly statements: IStatementVisitor;
     protected readonly conditions: IConditionVisitor;
-    constructor(statements?: (text: StatementTextRenderer) => StatementRenderer, conditions?: (expressions: ExpressionRenderer) => ConditionRenderer, expressions?: (text: StatementTextRenderer) => ExpressionRenderer);
+    readonly naming: StatementNaming;
+    private readonly statementsFactory?;
+    private readonly conditionsFactory?;
+    private readonly expressionsFactory?;
+    private readonly applyKeywordsFn?;
+    constructor(statements?: (text: StatementTextRenderer) => StatementRenderer, conditions?: (expressions: ExpressionRenderer) => ConditionRenderer, expressions?: (text: StatementTextRenderer) => ExpressionRenderer, naming?: StatementNaming, applyKeywords?: (sql: string, keyword: (word: string) => string) => string);
+    withNaming: (naming: StatementNaming) => StatementTextRenderer;
+    procedures: (source: ProcedureSource) => IStatement[];
+    applyKeywords: (sql: string) => string;
     render(statement: IStatement): string;
     render(condition: ICondition): string;
 }

package/dist/statements/StatementTextRenderer.js

@@ -1,17 +1,34 @@
 import { is } from "./brand.js";
 import { ConditionRenderer } from "./ConditionRenderer.js";
 import { ExpressionRenderer } from "./ExpressionRenderer.js";
+import { KeywordCasing } from "./KeywordCasing.js";
 import { StatementRenderer } from "./StatementRenderer.js";
+import { StatementNaming } from "./StatementNaming.js";
 import { Where } from "./Where.js";
 import { WhereText } from "./WhereText.js";
 export class StatementTextRenderer {
     statements;
     conditions;
-    constructor(statements, conditions, expressions) {
+    naming;
+    statementsFactory;
+    conditionsFactory;
+    expressionsFactory;
+    applyKeywordsFn;
+    constructor(statements, conditions, expressions, naming, applyKeywords) {
+        this.statementsFactory = statements;
+        this.conditionsFactory = conditions;
+        this.expressionsFactory = expressions;
+        this.applyKeywordsFn = applyKeywords;
+        this.naming = naming ?? StatementNaming.sql;
         const expressionRenderer = expressions?.(this) ?? new ExpressionRenderer(this);
         this.statements = statements?.(this) ?? new StatementRenderer(this);
         this.conditions = conditions?.(expressionRenderer) ?? new ConditionRenderer(expressionRenderer);
     }
+    withNaming = (naming) => new StatementTextRenderer(this.statementsFactory, this.conditionsFactory, this.expressionsFactory, naming, this.applyKeywordsFn);
+    procedures = (source) => this.statements instanceof StatementRenderer ? this.statements.procedures(source) : [];
+    applyKeywords = (sql) => this.naming.keywordCasing === KeywordCasing.Lower && this.applyKeywordsFn !== undefined
+        ? this.applyKeywordsFn(sql, this.naming.keyword)
+        : sql;
     render(target) {
         return is(target, Where) || is(target, WhereText)
             ? target.accept(this.conditions)

package/dist/statements/UniqueConstraint.d.ts

@@ -1,7 +1,9 @@
 import type { ITableConstraint } from "./ITableConstraint.js";
+import type { StatementNaming } from "./StatementNaming.js";
 export declare class UniqueConstraint implements ITableConstraint {
     readonly name: string;
     readonly columns: string[];
     readonly kind: "unique";
     constructor(name: string, columns: string[]);
+    static nameOf: (entity: string, naming: StatementNaming, ...parts: string[]) => string;
 }

package/dist/statements/UniqueConstraint.js

@@ -1,3 +1,4 @@
+import { constraintNameOf } from "./ConstraintName.js";
 export class UniqueConstraint {
     name;
     columns;
@@ -6,4 +7,5 @@ export class UniqueConstraint {
         this.name = name;
         this.columns = columns;
     }
+    static nameOf = (entity, naming, ...parts) => constraintNameOf(entity, naming, ...parts);
 }

package/dist/statements/index.d.ts

@@ -58,8 +58,19 @@ export { ExpressionEvaluator } from "./ExpressionEvaluator.js";
 export { StatementEvaluator } from "./StatementEvaluator.js";
 export { WhereText } from "./WhereText.js";
 export { SelectStatement } from "./SelectStatement.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 { StatementParser } from "./StatementParser.js";
 export { StatementTextRenderer } from "./StatementTextRenderer.js";
+export { StatementNaming } from "./StatementNaming.js";
+export { KeywordCasing } from "./KeywordCasing.js";
+export { constraintNameOf } from "./ConstraintName.js";
+export type { ProcedureSource, ProcedureByGroup } from "./ProcedureSource.js";
+export { sqlProcedureStatementsOf, procedureNameOf } from "./SqlProcedureStatements.js";
 export { DefaultStatementTextRenderer } from "./DefaultStatementTextRenderer.js";
 export { StatementRenderer } from "./StatementRenderer.js";
 export { ExpressionRenderer } from "./ExpressionRenderer.js";

package/dist/statements/index.js

@@ -14,8 +14,13 @@ export { ExpressionEvaluator } from "./ExpressionEvaluator.js";
 export { StatementEvaluator } from "./StatementEvaluator.js";
 export { WhereText } from "./WhereText.js";
 export { SelectStatement } from "./SelectStatement.js";
+export { NestedSelectBuilder } from "./NestedSelectBuilder.js";
 export { StatementParser } from "./StatementParser.js";
 export { StatementTextRenderer } from "./StatementTextRenderer.js";
+export { StatementNaming } from "./StatementNaming.js";
+export { KeywordCasing } from "./KeywordCasing.js";
+export { constraintNameOf } from "./ConstraintName.js";
+export { sqlProcedureStatementsOf, procedureNameOf } from "./SqlProcedureStatements.js";
 export { DefaultStatementTextRenderer } from "./DefaultStatementTextRenderer.js";
 export { StatementRenderer } from "./StatementRenderer.js";
 export { ExpressionRenderer } from "./ExpressionRenderer.js";

package/package.json

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