@deterministic-code/datasources-sqlserver 0.1.18 → 0.1.29

package/dist/DefaultValueConverter.d.ts

@@ -0,0 +1,25 @@
+import type { DefaultValueOptions } from "./DefaultValueOptions.js";
+export declare const EMPTY_UUID = "00000000-0000-0000-0000-000000000000";
+export type SpecToken = {
+    spec: RegExp;
+    specText?: (arg: string) => string;
+};
+export type DefaultEntry = SpecToken & {
+    native: (arg: string) => string;
+    reverse: RegExp;
+};
+type DefaultToken = {
+    token: string;
+    arg?: string | boolean;
+};
+export declare const sqlStringLiteral: (value: string | number | boolean | null | undefined) => string;
+export declare class DefaultValueConverter {
+    static readonly spec: Record<string, Record<string, SpecToken>>;
+    readonly dictionary: Record<string, Record<string, DefaultEntry>>;
+    constructor(options: DefaultValueOptions);
+    static parse(specType: string, value: unknown): DefaultToken;
+    convert: (specType: string, text: string) => string | null;
+    reverseConvert: (specType: string, native: string) => string;
+    private static dictionaryOf;
+}
+export {};

package/dist/DefaultValueConverter.js

@@ -0,0 +1,172 @@
+export const EMPTY_UUID = "00000000-0000-0000-0000-000000000000";
+const NUMERIC_TYPES = [
+    "integer",
+    "unsignedinteger",
+    "smallinteger",
+    "unsignedsmallinteger",
+    "biginteger",
+    "unsignedbiginteger",
+    "float",
+    "decimal",
+];
+const NUMERIC_LITERAL_TYPES = new Set([...NUMERIC_TYPES, "reference"]);
+const CALL_FORM = /^([A-Za-z]+)\('(.*)'\)$/;
+const quotedReverse = /^'(.*)'$/;
+const identity = (arg) => arg;
+const intLit = { spec: /^-?[0-9]+$/, specText: identity };
+const uintLit = { spec: /^[0-9]+$/, specText: identity };
+const floatLit = { spec: /^-?[0-9]+(\.[0-9]+)?$/, specText: identity };
+export const sqlStringLiteral = (value) => `'${String(value).replace(/'/g, "''")}'`;
+const escapeRe = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const exact = (text) => new RegExp(`^${escapeRe(text)}$`);
+const quoted = (arg) => sqlStringLiteral(arg);
+const callTokenName = (name) => (name === "uuid" ? "Uuid" : name);
+const token = (specToken, native, reverse) => ({
+    ...specToken,
+    native,
+    reverse,
+});
+export class DefaultValueConverter {
+    static spec = {
+        string: { String: { spec: /^.*$/, specText: identity } },
+        character: { String: { spec: /^.+$/, specText: identity } },
+        integer: { Numeric: intLit },
+        unsignedinteger: { Numeric: uintLit },
+        smallinteger: { Numeric: intLit },
+        unsignedsmallinteger: { Numeric: uintLit },
+        biginteger: { Numeric: intLit },
+        unsignedbiginteger: { Numeric: uintLit },
+        float: { Numeric: floatLit },
+        decimal: { Numeric: floatLit, String: { spec: /^.*$/, specText: identity } },
+        boolean: { Boolean: { spec: /^(true|false)$/, specText: identity } },
+        datetime: {
+            Now: { spec: /^Now$/ },
+            UtcNow: { spec: /^UtcNow$/ },
+            DateTime: {
+                spec: /^DateTime\('[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}(Z|[+-][0-9]{2}:[0-9]{2})'\)$/,
+                specText: (arg) => `DateTime('${arg}')`,
+            },
+        },
+        binary: {
+            Hex: { spec: /^Hex\('([0-9a-fA-F]{2})*'\)$/, specText: (arg) => `Hex('${arg}')` },
+        },
+        uuid: {
+            NewId: { spec: /^NewId$/ },
+            Empty: { spec: /^Empty$/ },
+            Uuid: {
+                spec: /^uuid\('[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}'\)$/,
+                specText: (arg) => `uuid('${arg}')`,
+            },
+        },
+        reference: {},
+    };
+    dictionary;
+    constructor(options) {
+        this.dictionary = DefaultValueConverter.dictionaryOf(options);
+    }
+    static parse(specType, value) {
+        if (value === undefined || value === null)
+            return { token: "None" };
+        const v = String(value);
+        const call = CALL_FORM.exec(v);
+        if (call !== null)
+            return { token: callTokenName(call[1]), arg: call[2] };
+        if (specType === "boolean") {
+            return { token: "Boolean", arg: typeof value === "boolean" ? value : v === "true" };
+        }
+        if (NUMERIC_LITERAL_TYPES.has(specType))
+            return { token: "Numeric", arg: v };
+        if (specType === "datetime") {
+            if (v === "Now")
+                return { token: "Now" };
+            if (v === "UtcNow")
+                return { token: "UtcNow" };
+            return { token: "DateTime", arg: v };
+        }
+        if (specType === "uuid") {
+            if (v === "NewId")
+                return { token: "NewId" };
+            if (v === "Empty")
+                return { token: "Empty" };
+            return { token: "Uuid", arg: v };
+        }
+        if (specType === "binary")
+            return { token: "Hex", arg: v };
+        return { token: "String", arg: v };
+    }
+    convert = (specType, text) => {
+        const parsed = DefaultValueConverter.parse(specType, text);
+        if (parsed.token === "None")
+            return null;
+        const entries = this.dictionary[specType];
+        if (entries === undefined)
+            throw new Error(`Unknown spec field type: ${specType}`);
+        const entry = entries[parsed.token];
+        if (entry === undefined)
+            return null;
+        if (!entry.spec.test(text)) {
+            throw new Error(`default_value '${text}' is not a valid ${specType} ${parsed.token} default`);
+        }
+        const expr = entry.native(parsed.arg === undefined ? "" : String(parsed.arg));
+        return expr === "" ? null : expr;
+    };
+    reverseConvert = (specType, native) => {
+        const entries = this.dictionary[specType];
+        if (entries === undefined)
+            throw new Error(`Unknown spec field type: ${specType}`);
+        for (const [name, entry] of Object.entries(entries)) {
+            const match = entry.reverse.exec(native);
+            if (match === null)
+                continue;
+            const arg = match.slice(1).find((group) => group !== undefined) ?? "";
+            return entry.specText === undefined ? name : entry.specText(arg);
+        }
+        throw new Error(`Native default '${native}' is not a valid ${specType} default`);
+    };
+    static dictionaryOf = (opts) => {
+        const spec = DefaultValueConverter.spec;
+        const newId = opts.newId();
+        const now = opts.now();
+        const utcNow = opts.utcNow();
+        const numericEntries = (type) => {
+            const numeric = spec[type].Numeric;
+            return {
+                Numeric: token(numeric, (arg) => arg, numeric.spec),
+                String: token(numeric, (arg) => arg, numeric.spec),
+            };
+        };
+        const quote = opts.quote ?? quoted;
+        const quoteReverse = opts.quoteReverse ?? quotedReverse;
+        const quotedString = {
+            String: token(spec.string.String, quote, quoteReverse),
+            Numeric: token(spec.string.String, quote, quoteReverse),
+        };
+        const dictionary = {
+            string: quotedString,
+            character: {
+                String: token(spec.character.String, quote, quoteReverse),
+                Numeric: token(spec.character.String, quote, quoteReverse),
+            },
+            boolean: {
+                Boolean: token(spec.boolean.Boolean, (arg) => (arg === "true" ? opts.booleanOn : opts.booleanOff), new RegExp(`^(${escapeRe(opts.booleanOn)}|${escapeRe(opts.booleanOff)})$`)),
+            },
+            datetime: {
+                Now: token(spec.datetime.Now, () => now, exact(now)),
+                UtcNow: token(spec.datetime.UtcNow, () => utcNow, exact(utcNow)),
+                DateTime: token(spec.datetime.DateTime, quoted, quotedReverse),
+            },
+            binary: {
+                Hex: token(spec.binary.Hex, opts.hex, opts.hexReverse),
+            },
+            uuid: {
+                NewId: token(spec.uuid.NewId, () => newId, exact(newId)),
+                Empty: token(spec.uuid.Empty, () => quoted(EMPTY_UUID), exact(quoted(EMPTY_UUID))),
+                Uuid: token(spec.uuid.Uuid, quoted, quotedReverse),
+            },
+            reference: {},
+        };
+        for (const type of NUMERIC_TYPES)
+            dictionary[type] = numericEntries(type);
+        return dictionary;
+    };
+}

package/dist/DefaultValueOptions.d.ts

@@ -0,0 +1,11 @@
+export type DefaultValueOptions = {
+    newId: () => string;
+    now: () => string;
+    utcNow: () => string;
+    booleanOn: string;
+    booleanOff: string;
+    hex: (arg: string) => string;
+    hexReverse: RegExp;
+    quote?: (arg: string) => string;
+    quoteReverse?: RegExp;
+};

package/dist/DefaultValueOptions.js

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

package/dist/SqlServerAlterTableStatementRenderer.d.ts

@@ -1,5 +1,8 @@
-import { AlterTableStatementTextRenderer, type AlterAction, type AlterTableStatement } from "@deterministic-code/datasources";
+import { AlterTableStatementTextRenderer, type AlterAction, type AlterTableStatement, type Column } from "@deterministic-code/datasources";
 export declare class SqlServerAlterTableStatementRenderer extends AlterTableStatementTextRenderer {
+    protected quote(name: string): string;
+    protected typeName(column: Column): string;
+    protected columnDefault(column: Column): string;
     renderAlter(statement: AlterTableStatement): string;
     protected actionSql(action: AlterAction): string;
 }

package/dist/SqlServerAlterTableStatementRenderer.js

@@ -1,5 +1,19 @@
 import { AlterTableStatementTextRenderer, } from "@deterministic-code/datasources";
+import { SqlServerDriver } from "./SqlServerDriver.js";
 export class SqlServerAlterTableStatementRenderer extends AlterTableStatementTextRenderer {
+    quote(name) {
+        return SqlServerDriver.quote(name);
+    }
+    typeName(column) {
+        return SqlServerDriver.nativeType(column);
+    }
+    columnDefault(column) {
+        return column.default == null
+            ? ""
+            : column.default.name == null
+                ? ` DEFAULT ${SqlServerDriver.nativeDefault(column)}`
+                : ` CONSTRAINT ${this.quote(column.default.name)} DEFAULT ${SqlServerDriver.nativeDefault(column)}`;
+    }
     renderAlter(statement) {
         return statement.action.kind === "renameColumn"
             ? `EXEC sp_rename '${statement.table}.${statement.action.from}', '${statement.action.to}', 'COLUMN'`

package/dist/SqlServerCreateTableStatementRenderer.d.ts

@@ -1,4 +1,7 @@
 import { CreateTableStatementTextRenderer, type Column } from "@deterministic-code/datasources";
 export declare class SqlServerCreateTableStatementRenderer extends CreateTableStatementTextRenderer {
+    protected quote(name: string): string;
+    protected typeName(column: Column): string;
+    protected columnDefault(column: Column): string;
     protected identity(column: Column): string;
 }

package/dist/SqlServerCreateTableStatementRenderer.js

@@ -1,5 +1,19 @@
 import { CreateTableStatementTextRenderer } from "@deterministic-code/datasources";
+import { SqlServerDriver } from "./SqlServerDriver.js";
 export class SqlServerCreateTableStatementRenderer extends CreateTableStatementTextRenderer {
+    quote(name) {
+        return SqlServerDriver.quote(name);
+    }
+    typeName(column) {
+        return SqlServerDriver.nativeType(column);
+    }
+    columnDefault(column) {
+        return column.default == null
+            ? ""
+            : column.default.name == null
+                ? ` DEFAULT ${SqlServerDriver.nativeDefault(column)}`
+                : ` CONSTRAINT ${this.quote(column.default.name)} DEFAULT ${SqlServerDriver.nativeDefault(column)}`;
+    }
     identity(column) {
         return column.identity ? " IDENTITY(1,1)" : "";
     }

package/dist/SqlServerCreateTriggerStatementRenderer.js

@@ -1,12 +1,16 @@
 import { CreateTriggerStatementTextRenderer } from "@deterministic-code/datasources";
+import { SqlServerDriver } from "./SqlServerDriver.js";
 export class SqlServerCreateTriggerStatementRenderer extends CreateTriggerStatementTextRenderer {
     render(statement) {
-        return `CREATE TRIGGER ${statement.name} ON ${statement.table}
+        const table = SqlServerDriver.quote(statement.table);
+        const updated = SqlServerDriver.quote(statement.updatedColumn);
+        const key = SqlServerDriver.quote(statement.keyColumn);
+        return `CREATE TRIGGER ${SqlServerDriver.quote(statement.name)} ON ${table}
 AFTER UPDATE AS
 BEGIN
   SET NOCOUNT ON;
-  UPDATE ${statement.table} SET ${statement.updatedColumn} = ${statement.utcNow}
-  FROM ${statement.table} t INNER JOIN inserted i ON t.${statement.keyColumn} = i.${statement.keyColumn};
+  UPDATE ${table} SET ${updated} = ${SqlServerDriver.utcNow()}
+  FROM ${table} t INNER JOIN inserted i ON t.${key} = i.${key};
 END`;
     }
 }

package/dist/SqlServerDriver.d.ts

@@ -1,11 +1,24 @@
-import { DefaultValueConverter, DeterministicTypeConverter, StatementTextRenderer, type Cell, type DatasourceOptions, type ICommand, type IConnection, type IDriver, type Information, type ITransaction, type IsolationLevel, type TypeConverter } from "@deterministic-code/datasources";
+import { StatementTextRenderer, type Cell, type Column, type DatasourceOptions, type ICommand, type IConnection, type IDriver, type Information, type ITransaction, type IsolationLevel, type RoutineParameter, type TypeConverter } from "@deterministic-code/datasources";
+import { TypeMap } from "./TypeMap.js";
+import { DefaultValueConverter } from "./DefaultValueConverter.js";
 export declare class SqlServerDriver implements IDriver {
+    static readonly procedurePayloadType = "NVARCHAR(MAX)";
+    static procedureSpecs: (entityName: string, byGroups: string[][], casing: {
+        routineName: (stem: string) => string;
+        pluralStem: (entity: string) => string;
+    }) => import("./procedureSpecs.js").ProcSpec[];
+    static applyKeywords: (sql: string, keyword: (word: string) => string) => string;
+    static quote: (name: string) => string;
+    static nativeType: (column: Column) => string;
+    static nativeDefault: (column: Column) => string;
+    static utcNow: () => string;
+    static nativeParam: (parameter: RoutineParameter) => string;
     readonly statementRenderer: StatementTextRenderer;
     readonly information: Information;
     rowTypeConverters: Record<string, TypeConverter<Cell, Cell>>;
     readonly quoteLeft = "[";
     readonly quoteRight = "]";
-    readonly typeConverter: DeterministicTypeConverter;
+    readonly typeConverter: TypeMap;
     readonly defaultValueConverter: DefaultValueConverter;
     columnType: (name: string) => string;
     connection: (options?: DatasourceOptions) => IConnection;

package/dist/SqlServerDriver.js

@@ -1,8 +1,54 @@
-import { columnType as identityColumnType, DefaultValueConverter, DeterministicTypeConverter, StatementTextRenderer, StubTransaction, } from "@deterministic-code/datasources";
+import { columnType as identityColumnType, StatementTextRenderer, StubTransaction, } from "@deterministic-code/datasources";
 import { SqlServerConnection } from "./connection.js";
 import { SqlServerStatementRenderer } from "./SqlServerStatementRenderer.js";
+import { procedureSpecs } from "./procedureSpecs.js";
+import { applyKeywords } from "./applyKeywords.js";
+import { TypeMap } from "./TypeMap.js";
+import { DefaultValueConverter } from "./DefaultValueConverter.js";
 const statements = new StatementTextRenderer(t => new SqlServerStatementRenderer(t));
+const types = new TypeMap({
+    string: "NVARCHAR(MAX)",
+    character: "NCHAR(1)",
+    integer: "INT",
+    unsignedinteger: "BIGINT",
+    smallinteger: "SMALLINT",
+    unsignedsmallinteger: "INT",
+    biginteger: "BIGINT",
+    unsignedbiginteger: "DECIMAL(20)",
+    float: "FLOAT",
+    decimal: "DECIMAL",
+    boolean: "BIT",
+    datetime: "DATETIME2",
+    binary: "VARBINARY(MAX)",
+    uuid: "UNIQUEIDENTIFIER",
+    reference: "INT",
+});
+const defaults = new DefaultValueConverter({
+    newId: () => "NEWID()",
+    now: () => "GETDATE()",
+    utcNow: () => "GETUTCDATE()",
+    booleanOn: "1",
+    booleanOff: "0",
+    hex: (arg) => `0x${arg}`,
+    hexReverse: /^0x(.*)$/,
+});
 export class SqlServerDriver {
+    static procedurePayloadType = "NVARCHAR(MAX)";
+    static procedureSpecs = procedureSpecs;
+    static applyKeywords = applyKeywords;
+    static quote = (name) => `[${name}]`;
+    static nativeType = (column) => column.field ? types.convertField(column.field) : column.type;
+    static nativeDefault = (column) => column.default == null
+        ? ""
+        : column.field === undefined
+            ? column.default.value
+            : defaults.convert(column.field.type, column.default.value) ?? column.default.value;
+    static utcNow = () => defaults.convert("datetime", "UtcNow") ?? "";
+    static nativeParam = (parameter) => parameter.type === "payload"
+        ? SqlServerDriver.procedurePayloadType
+        : parameter.field
+            ? types.convertField(parameter.field)
+            : types.dictionary[parameter.type] ?? parameter.type;
     statementRenderer = statements;
     information = {
         descriptions: ["SQL Server driver."],
@@ -20,40 +66,8 @@ export class SqlServerDriver {
     rowTypeConverters = {};
     quoteLeft = "[";
     quoteRight = "]";
-    typeConverter = new DeterministicTypeConverter({
-        string: "NVARCHAR(MAX)",
-        character: "NCHAR(1)",
-        integer: "INT",
-        unsignedinteger: "BIGINT",
-        smallinteger: "SMALLINT",
-        unsignedsmallinteger: "INT",
-        biginteger: "BIGINT",
-        unsignedbiginteger: "DECIMAL(20)",
-        float: "FLOAT",
-        decimal: "DECIMAL",
-        boolean: "BIT",
-        datetime: "DATETIME2",
-        binary: "VARBINARY(MAX)",
-        uuid: "UNIQUEIDENTIFIER",
-        reference: "INT",
-    }, {
-        dialectName: "sqlserver",
-        stringUnlimited: "NVARCHAR(MAX)",
-        stringSized: (n) => `NVARCHAR(${n})`,
-        character: "NCHAR",
-        decimal: { kind: "required", type: "DECIMAL" },
-        binaryUnlimited: "VARBINARY(MAX)",
-        binarySized: (n) => `VARBINARY(${n})`,
-    });
-    defaultValueConverter = new DefaultValueConverter({
-        newId: () => "NEWID()",
-        now: () => "GETDATE()",
-        utcNow: () => "GETUTCDATE()",
-        booleanOn: "1",
-        booleanOff: "0",
-        hex: (arg) => `0x${arg}`,
-        hexReverse: /^0x(.*)$/,
-    });
+    typeConverter = types;
+    defaultValueConverter = defaults;
     columnType = identityColumnType;
     connection = (options) => SqlServerConnection.from(options);
     command = (connection) => connection.createCommand();

package/dist/SqlServerDropIndexStatementRenderer.js

@@ -1,6 +1,7 @@
 import { DropIndexStatementTextRenderer } from "@deterministic-code/datasources";
+import { SqlServerDriver } from "./SqlServerDriver.js";
 export class SqlServerDropIndexStatementRenderer extends DropIndexStatementTextRenderer {
     render(statement) {
-        return `DROP INDEX ${statement.name} ON ${statement.table}`;
+        return `DROP INDEX ${SqlServerDriver.quote(statement.name)} ON ${SqlServerDriver.quote(statement.table)}`;
     }
 }

package/dist/SqlServerQuotedRenderers.d.ts

@@ -0,0 +1,13 @@
+import { CreateIndexStatementTextRenderer, DropTableStatementTextRenderer, DropTriggerStatementTextRenderer, type ForeignKeyStatement } from "@deterministic-code/datasources";
+export declare class SqlServerDropTableStatementRenderer extends DropTableStatementTextRenderer {
+    protected quote(name: string): string;
+}
+export declare class SqlServerCreateIndexStatementRenderer extends CreateIndexStatementTextRenderer {
+    protected quote(name: string): string;
+}
+export declare class SqlServerDropTriggerStatementRenderer extends DropTriggerStatementTextRenderer {
+    protected quote(name: string): string;
+}
+export declare class SqlServerForeignKeyStatementRenderer {
+    render(statement: ForeignKeyStatement): string;
+}

package/dist/SqlServerQuotedRenderers.js

@@ -0,0 +1,28 @@
+import { CreateIndexStatementTextRenderer, DropTableStatementTextRenderer, DropTriggerStatementTextRenderer, } from "@deterministic-code/datasources";
+import { SqlServerDriver } from "./SqlServerDriver.js";
+export class SqlServerDropTableStatementRenderer extends DropTableStatementTextRenderer {
+    quote(name) {
+        return SqlServerDriver.quote(name);
+    }
+}
+export class SqlServerCreateIndexStatementRenderer extends CreateIndexStatementTextRenderer {
+    quote(name) {
+        return SqlServerDriver.quote(name);
+    }
+}
+export class SqlServerDropTriggerStatementRenderer extends DropTriggerStatementTextRenderer {
+    quote(name) {
+        return SqlServerDriver.quote(name);
+    }
+}
+export class SqlServerForeignKeyStatementRenderer {
+    render(statement) {
+        const table = SqlServerDriver.quote(statement.table);
+        const name = SqlServerDriver.quote(statement.name);
+        if (statement.kind === "drop")
+            return `ALTER TABLE ${table} DROP CONSTRAINT ${name}`;
+        const cols = statement.columns.map(SqlServerDriver.quote).join(", ");
+        const refs = statement.referencesColumns.map(SqlServerDriver.quote).join(", ");
+        return `ALTER TABLE ${table} ADD CONSTRAINT ${name} FOREIGN KEY (${cols}) REFERENCES ${SqlServerDriver.quote(statement.referencesTable)} (${refs})`;
+    }
+}

package/dist/SqlServerSqlSeedStatementRenderer.d.ts

@@ -0,0 +1,4 @@
+import type { SqlSeedStatement } from "@deterministic-code/datasources";
+export declare class SqlServerSqlSeedStatementRenderer {
+    render(statement: SqlSeedStatement): string;
+}

package/dist/SqlServerSqlSeedStatementRenderer.js

@@ -0,0 +1,52 @@
+const quote = (ident) => `[${ident}]`;
+const quoteString = (value) => `'${String(value).replace(/'/g, "''")}'`;
+const truthy = (value) => value === true || value === "true" || value === "True" || value === 1;
+const numeric = new Set([
+    "integer",
+    "unsignedinteger",
+    "smallinteger",
+    "unsignedsmallinteger",
+    "biginteger",
+    "unsignedbiginteger",
+    "reference",
+    "float",
+    "decimal",
+]);
+const defaultSql = (type, def) => {
+    const text = String(def);
+    if (type === "datetime" && text === "UtcNow")
+        return "GETUTCDATE()";
+    if (type === "datetime" && text === "Now")
+        return "GETDATE()";
+    if (type === "uuid" && text === "NewId")
+        return "NEWID()";
+    if (type === "boolean")
+        return text === "true" || text === "True" ? "1" : "0";
+    return quoteString(text);
+};
+const literal = (column) => {
+    if (column.value == null)
+        return column.field.defaultValue != null ? defaultSql(column.field.type, column.field.defaultValue) : "NULL";
+    if (column.field.type === "boolean")
+        return truthy(column.value) ? "1" : "0";
+    if (numeric.has(column.field.type))
+        return String(column.value);
+    if (column.field.type === "binary")
+        return `0x${column.value}`;
+    return quoteString(column.value);
+};
+export class SqlServerSqlSeedStatementRenderer {
+    render(statement) {
+        const table = quote(statement.table);
+        if (statement.kind === "delete") {
+            const key = statement.columns[0];
+            return `DELETE FROM ${table} WHERE ${quote(key.column)} = ${literal(key)}`;
+        }
+        const cols = statement.columns.map((c) => quote(c.column)).join(", ");
+        const values = statement.columns.map(literal).join(", ");
+        const insert = `INSERT INTO ${table} (${cols}) VALUES (${values})`;
+        return !statement.identity
+            ? insert
+            : `SET IDENTITY_INSERT ${table} ON;\n${insert};\nSET IDENTITY_INSERT ${table} OFF`;
+    }
+}

package/dist/SqlServerStatementRenderer.d.ts

@@ -1,4 +1,4 @@
-import { AlterTableStatement, CreateBulkCreateStoredProcedureStatement, CreateBulkDeleteStoredProcedureStatement, CreateBulkUpdateStoredProcedureStatement, CreateCreateStoredProcedureStatement, CreateDeleteStoredProcedureStatement, CreateNestedReadStoredProcedureStatement, CreateReadStoredProcedureStatement, CreateTableStatement, CreateTriggerStatement, CreateUpdateStoredProcedureStatement, DropIndexStatement, DropRoutineStatement, IdentityInsertStatement, StatementRenderer, type StatementTextRenderer } from "@deterministic-code/datasources";
+import { AlterTableStatement, CreateBulkCreateStoredProcedureStatement, CreateBulkDeleteStoredProcedureStatement, CreateBulkUpdateStoredProcedureStatement, CreateCreateStoredProcedureStatement, CreateDeleteStoredProcedureStatement, CreateNestedReadStoredProcedureStatement, CreateReadStoredProcedureStatement, CreateIndexStatement, CreateTableStatement, CreateTriggerStatement, CreateUpdateStoredProcedureStatement, DropIndexStatement, DropRoutineStatement, DropTableStatement, ForeignKeyStatement, IdentityInsertStatement, SqlSeedStatement, StatementRenderer, type StatementTextRenderer } from "@deterministic-code/datasources";
 export declare class SqlServerStatementRenderer extends StatementRenderer {
     constructor(text: StatementTextRenderer);
     protected visitCreateTable(create: CreateTableStatement): string;
@@ -15,4 +15,8 @@ export declare class SqlServerStatementRenderer extends StatementRenderer {
     protected visitCreateBulkCreateStoredProcedureStatement(statement: CreateBulkCreateStoredProcedureStatement): string;
     protected visitCreateBulkUpdateStoredProcedureStatement(statement: CreateBulkUpdateStoredProcedureStatement): string;
     protected visitCreateBulkDeleteStoredProcedureStatement(statement: CreateBulkDeleteStoredProcedureStatement): string;
+    protected visitSqlSeed(seed: SqlSeedStatement): string;
+    protected visitDropTable(drop: DropTableStatement): string;
+    protected visitCreateIndex(index: CreateIndexStatement): string;
+    protected visitForeignKey(key: ForeignKeyStatement): string;
 }

package/dist/SqlServerStatementRenderer.js

@@ -6,6 +6,8 @@ import { SqlServerDropIndexStatementRenderer } from "./SqlServerDropIndexStateme
 import { SqlServerDropRoutineStatementRenderer } from "./SqlServerDropRoutineStatementRenderer.js";
 import { SqlServerStoredProcedureStatementRenderer } from "./SqlServerStoredProcedureStatementRenderer.js";
 import { SqlServerIdentityInsertStatementRenderer } from "./SqlServerIdentityInsertStatementRenderer.js";
+import { SqlServerSqlSeedStatementRenderer } from "./SqlServerSqlSeedStatementRenderer.js";
+import { SqlServerCreateIndexStatementRenderer, SqlServerDropTableStatementRenderer, SqlServerForeignKeyStatementRenderer, } from "./SqlServerQuotedRenderers.js";
 export class SqlServerStatementRenderer extends StatementRenderer {
     constructor(text) {
         super(text);
@@ -52,4 +54,16 @@ export class SqlServerStatementRenderer extends StatementRenderer {
     visitCreateBulkDeleteStoredProcedureStatement(statement) {
         return new SqlServerStoredProcedureStatementRenderer().renderBulkDelete(statement);
     }
+    visitSqlSeed(seed) {
+        return new SqlServerSqlSeedStatementRenderer().render(seed);
+    }
+    visitDropTable(drop) {
+        return new SqlServerDropTableStatementRenderer().render(drop);
+    }
+    visitCreateIndex(index) {
+        return new SqlServerCreateIndexStatementRenderer().render(index);
+    }
+    visitForeignKey(key) {
+        return new SqlServerForeignKeyStatementRenderer().render(key);
+    }
 }

package/dist/SqlServerStoredProcedureStatementRenderer.js

@@ -1,6 +1,8 @@
 import { DefaultStatementTextRenderer } from "@deterministic-code/datasources";
-const params = (list) => list.map((p) => `  @${p.name} ${p.type}`).join(",\n");
-const openjson = (columns) => columns.map((c) => `${c.name} ${c.type} '$.${c.name}'`).join(", ");
+import { SqlServerDriver } from "./SqlServerDriver.js";
+const typeOf = (parameter) => SqlServerDriver.nativeParam(parameter);
+const params = (list) => list.map((p) => `  @${p.name} ${typeOf(p)}`).join(",\n");
+const openjson = (columns) => columns.map((c) => `${c.name} ${typeOf(c)} '$.${c.name}'`).join(", ");
 export class SqlServerStoredProcedureStatementRenderer {
     renderCreate(statement) {
         return `CREATE OR ALTER PROCEDURE ${statement.name}
@@ -16,7 +18,7 @@ GO`;
     renderNestedRead(statement) {
         const select = DefaultStatementTextRenderer.instance.render(statement.select);
         const signature = statement.arguments
-            .map((argument) => `  @${argument.parameter.name} ${argument.parameter.type}`)
+            .map((argument) => `  @${argument.parameter.name} ${typeOf(argument.parameter)}`)
             .join(",\n");
         return `CREATE OR ALTER PROCEDURE ${statement.name}
 ${signature}
@@ -37,7 +39,7 @@ END;
 GO`;
         }
         const signature = statement.byProperties
-            .map((c) => `@${c} ${statement.parameters.find((p) => p.name === c)?.type ?? statement.keyType}`)
+            .map((c) => `@${c} ${typeOf(statement.parameters.find((p) => p.name === c) ?? { name: c, type: statement.keyType })}`)
             .join(", ");
         const pred = statement.byProperties.map((c) => `${c} = @${c}`).join(" AND ");
         return `CREATE OR ALTER PROCEDURE ${statement.name} ${signature}
@@ -71,7 +73,7 @@ GO`;
     renderDelete(statement) {
         const by = statement.byProperties.length > 0 ? statement.byProperties : [statement.key];
         const signature = by
-            .map((c) => `@${c} ${statement.parameters.find((p) => p.name === c)?.type ?? statement.keyType}`)
+            .map((c) => `@${c} ${typeOf(statement.parameters.find((p) => p.name === c) ?? { name: c, type: statement.keyType })}`)
             .join(", ");
         const pred = by.map((c) => `${c} = @${c}`).join(" AND ");
         return `CREATE OR ALTER PROCEDURE ${statement.name} ${signature}
@@ -118,7 +120,7 @@ GO`;
 AS
 BEGIN
   DELETE t FROM ${statement.table} t
-  JOIN OPENJSON(@${statement.payload.name}) WITH (${statement.key} ${statement.keyType} '$.${statement.key}') AS payload_rows
+  JOIN OPENJSON(@${statement.payload.name}) WITH (${statement.key} ${SqlServerDriver.nativeParam({ name: statement.key, type: statement.keyType })} '$.${statement.key}') AS payload_rows
     ON t.${statement.key} = payload_rows.${statement.key};
 END;
 GO`;

package/dist/TypeMap.d.ts

@@ -0,0 +1,9 @@
+import type { IMapping, SpecField } from "@deterministic-code/datasources";
+export declare class TypeMap implements IMapping<string, string> {
+    readonly dictionary: Record<string, string>;
+    private readonly reverse;
+    constructor(dictionary: Record<string, string>);
+    convert: (from: string) => string;
+    convertField: (field: SpecField) => string;
+    reverseConvert: (native: string) => string;
+}

package/dist/TypeMap.js

@@ -0,0 +1,35 @@
+export class TypeMap {
+    dictionary;
+    reverse = new Map();
+    constructor(dictionary) {
+        this.dictionary = dictionary;
+        for (const [spec, native] of Object.entries(dictionary)) {
+            if (!this.reverse.has(native))
+                this.reverse.set(native, spec);
+        }
+    }
+    convert = (from) => this.dictionary[from] ??
+        (() => {
+            throw new Error(`Unknown spec field type: ${from}`);
+        })();
+    convertField = (field) => {
+        if (field.type === "string")
+            return field.size == null || field.size === "unlimited" ? "NVARCHAR(MAX)" : `NVARCHAR(${field.size})`;
+        if (field.type === "character")
+            return `NCHAR(${field.size == null ? 1 : Number(field.size)})`;
+        if (field.type === "decimal") {
+            if (field.size == null)
+                return "DECIMAL";
+            if (Array.isArray(field.size) && field.size.length === 2)
+                return `DECIMAL(${field.size[0]}, ${field.size[1]})`;
+            throw new Error(`decimal field "${field.name}" size must be [precision, scale] tuple; got ${field.size}`);
+        }
+        if (field.type === "binary")
+            return field.size == null || field.size === "unlimited" ? "VARBINARY(MAX)" : `VARBINARY(${field.size})`;
+        return this.convert(field.type);
+    };
+    reverseConvert = (native) => this.reverse.get(native) ??
+        (() => {
+            throw new Error(`Unknown native field type: ${native}`);
+        })();
+}

package/dist/applyKeywords.d.ts

@@ -0,0 +1 @@
+export declare const applyKeywords: (sql: string, keyword: (word: string) => string) => string;

package/dist/applyKeywords.js

@@ -0,0 +1,14 @@
+const KEYWORDS = new Set([
+    "AFTER", "ALTER", "AND", "AS", "AT", "BEGIN", "BETWEEN", "BIGINT", "BIT", "BY", "CASCADE",
+    "CAST", "CHAR", "CONSTRAINT", "CREATE", "DATETIME", "DATETIME2", "DECIMAL", "DECLARE",
+    "DEFAULT", "DELETE", "DROP", "EACH", "ELSE", "END", "EXECUTE", "EXISTS", "FALSE", "FLOAT",
+    "FOR", "FOREIGN", "FROM", "GET", "GETDATE", "GETUTCDATE", "GO", "IDENTITY", "IDENTITY_INSERT",
+    "IF", "IN", "INDEX", "INNER", "INSERT", "INT", "INTEGER", "INTO", "JOIN", "KEY", "MAX",
+    "NCHAR", "NEWID", "NOCOUNT", "NOT", "NULL", "NVARCHAR", "OFF", "ON", "OR", "ORDER",
+    "PRECISION", "PRIMARY", "PROCEDURE", "REFERENCES", "RETURN", "ROW", "ROWCOUNT",
+    "SCOPE_IDENTITY", "SELECT", "SET", "SMALLINT", "TABLE", "TEXT", "THEN", "TIME", "TIMESTAMP",
+    "TINYINT", "TRIGGER", "TRUE", "UNIQUE", "UNIQUEIDENTIFIER", "UPDATE", "VALUES", "VARBINARY",
+    "VARCHAR", "WHEN", "WHERE",
+]);
+const TOKEN = /('(?:''|[^'])*')|(\[[^\]]*\])|(--[^\n]*)|(\/\*[\s\S]*?\*\/)|(?<word>[A-Za-z_][A-Za-z0-9_]*)/g;
+export const applyKeywords = (sql, keyword) => sql.replace(TOKEN, (match, _s, _br, _lc, _bc, word) => word !== undefined && KEYWORDS.has(word.toUpperCase()) ? keyword(word) : match);

package/dist/procedureSpecs.d.ts

@@ -0,0 +1,10 @@
+export type ProcOp = "create" | "read" | "update" | "delete" | "bulkCreate" | "bulkUpdate" | "bulkDelete";
+export type ProcSpec = {
+    op: ProcOp;
+    name: string;
+    byProperties: string[];
+};
+export declare const procedureSpecs: (entityName: string, byGroups: string[][], casing: {
+    routineName: (stem: string) => string;
+    pluralStem: (entity: string) => string;
+}) => ProcSpec[];

package/dist/procedureSpecs.js

@@ -0,0 +1,17 @@
+export const procedureSpecs = (entityName, byGroups, casing) => {
+    const name = (stem) => casing.routineName(stem);
+    const plural = casing.pluralStem(entityName);
+    const bySuffix = (props) => props.length === 0 ? "" : `_by_${props.join("_")}`;
+    return [
+        { op: "create", name: name(`create_${plural}`), byProperties: [] },
+        { op: "read", name: name(`read_${plural}`), byProperties: [] },
+        ...byGroups.flatMap((props) => [
+            { op: "read", name: name(`read_${plural}${bySuffix(props)}`), byProperties: props },
+            { op: "update", name: name(`update_${plural}${bySuffix(props)}`), byProperties: props },
+            { op: "delete", name: name(`delete_${plural}${bySuffix(props)}`), byProperties: props },
+        ]),
+        { op: "bulkCreate", name: name(`bulk_create_${plural}`), byProperties: [] },
+        { op: "bulkUpdate", name: name(`bulk_update_${plural}`), byProperties: [] },
+        { op: "bulkDelete", name: name(`bulk_delete_${plural}`), byProperties: [] },
+    ];
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deterministic-code/datasources-sqlserver",
-  "version": "0.1.18",
+  "version": "0.1.29",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.js",
@@ -18,6 +18,6 @@
     "access": "public"
   },
   "dependencies": {
-    "@deterministic-code/datasources": "^0.1.18"
+    "@deterministic-code/datasources": "^0.1.29"
   }
 }