@deterministic-code/datasources-sqlserver 0.0.0-stage → 0.1.2

package/dist/SqlServerAlterTableStatementRenderer.d.ts

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

package/dist/SqlServerAlterTableStatementRenderer.js

@@ -0,0 +1,15 @@
+import { AlterTableStatementTextRenderer, } from "@deterministic-code/datasources";
+export class SqlServerAlterTableStatementRenderer extends AlterTableStatementTextRenderer {
+    renderAlter(statement) {
+        return statement.action.kind === "renameColumn"
+            ? `EXEC sp_rename '${statement.table}.${statement.action.from}', '${statement.action.to}', 'COLUMN'`
+            : statement.action.kind === "renameTable"
+                ? `EXEC sp_rename '${statement.table}', '${statement.action.to}'`
+                : super.renderAlter(statement);
+    }
+    actionSql(action) {
+        return action.kind === "alterColumn"
+            ? `ALTER COLUMN ${this.quote(action.column.name)} ${this.typeName(action.column)}${this.notNullClause(action.column)}`
+            : super.actionSql(action);
+    }
+}

package/dist/SqlServerCreateTableStatementRenderer.d.ts

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

package/dist/SqlServerCreateTableStatementRenderer.js

@@ -0,0 +1,6 @@
+import { CreateTableStatementTextRenderer } from "@deterministic-code/datasources";
+export class SqlServerCreateTableStatementRenderer extends CreateTableStatementTextRenderer {
+    identity(column) {
+        return column.identity ? " IDENTITY(1,1)" : "";
+    }
+}

package/dist/SqlServerCreateTriggerStatementRenderer.d.ts

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

package/dist/SqlServerCreateTriggerStatementRenderer.js

@@ -0,0 +1,12 @@
+import { CreateTriggerStatementTextRenderer } from "@deterministic-code/datasources";
+export class SqlServerCreateTriggerStatementRenderer extends CreateTriggerStatementTextRenderer {
+    render(statement) {
+        return `CREATE TRIGGER ${statement.name} ON ${statement.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};
+END`;
+    }
+}

package/dist/SqlServerDriver.d.ts

@@ -0,0 +1,14 @@
+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";
+export declare class SqlServerDriver implements IDriver {
+    readonly statementRenderer: StatementTextRenderer;
+    readonly information: Information;
+    rowTypeConverters: Record<string, TypeConverter<Cell, Cell>>;
+    readonly quoteLeft = "[";
+    readonly quoteRight = "]";
+    readonly typeConverter: DeterministicTypeConverter;
+    readonly defaultValueConverter: DefaultValueConverter;
+    columnType: (name: string) => string;
+    connection: (options?: DatasourceOptions) => IConnection;
+    command: (connection: IConnection) => ICommand;
+    transaction: (connection: IConnection, _isolation?: IsolationLevel) => ITransaction;
+}

package/dist/SqlServerDriver.js

@@ -0,0 +1,62 @@
+import { columnType as identityColumnType, DefaultValueConverter, DeterministicTypeConverter, StatementTextRenderer, StubTransaction, } from "@deterministic-code/datasources";
+import { SqlServerConnection } from "./connection.js";
+import { SqlServerStatementRenderer } from "./SqlServerStatementRenderer.js";
+const statements = new StatementTextRenderer(t => new SqlServerStatementRenderer(t));
+export class SqlServerDriver {
+    statementRenderer = statements;
+    information = {
+        descriptions: ["SQL Server driver."],
+        overrides: [
+            "Overrides CreateCreateStoredProcedureStatement to PROCEDURE Create{Plural}",
+            "Overrides CreateReadStoredProcedureStatement to PROCEDURE Read{Plural}By{Properties}",
+            "Overrides CreateUpdateStoredProcedureStatement to PROCEDURE Update{Plural}By{Properties}",
+            "Overrides CreateDeleteStoredProcedureStatement to PROCEDURE Delete{Plural}By{Properties}",
+            "Overrides CreateBulkCreateStoredProcedureStatement to PROCEDURE BulkCreate{Plural}",
+            "Overrides CreateBulkUpdateStoredProcedureStatement to PROCEDURE BulkUpdate{Plural}",
+            "Overrides CreateBulkDeleteStoredProcedureStatement to PROCEDURE BulkDelete{Plural}",
+        ],
+        changeLogs: [],
+    };
+    rowTypeConverters = {};
+    quoteLeft = "[";
+    quoteRight = "]";
+    typeConverter = new DeterministicTypeConverter({
+        string: "NVARCHAR(MAX)",
+        character: "NCHAR(1)",
+        number: "INT",
+        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(.*)$/,
+    });
+    columnType = identityColumnType;
+    connection = (options) => SqlServerConnection.from(options);
+    command = (connection) => connection.createCommand();
+    transaction = (connection, _isolation) => new StubTransaction(connection.provider, connection);
+}

package/dist/SqlServerDropIndexStatementRenderer.d.ts

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

package/dist/SqlServerDropIndexStatementRenderer.js

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

package/dist/SqlServerDropRoutineStatementRenderer.d.ts

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

package/dist/SqlServerDropRoutineStatementRenderer.js

@@ -0,0 +1,6 @@
+import { DropRoutineStatementTextRenderer } from "@deterministic-code/datasources";
+export class SqlServerDropRoutineStatementRenderer extends DropRoutineStatementTextRenderer {
+    render(statement) {
+        return `DROP PROCEDURE IF EXISTS ${statement.name}`;
+    }
+}

package/dist/SqlServerIdentityInsertStatementRenderer.d.ts

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

package/dist/SqlServerIdentityInsertStatementRenderer.js

@@ -0,0 +1,12 @@
+import { IdentityInsertStatementTextRenderer, } from "@deterministic-code/datasources";
+export class SqlServerIdentityInsertStatementRenderer extends IdentityInsertStatementTextRenderer {
+    render(statement) {
+        const inserts = super.render(statement);
+        if (!statement.identity || statement.inserts.length === 0)
+            return inserts;
+        const quoted = statement.inserts[0].table;
+        return `SET IDENTITY_INSERT ${quoted} ON;
+${inserts}
+SET IDENTITY_INSERT ${quoted} OFF`;
+    }
+}

package/dist/SqlServerStatementRenderer.d.ts

@@ -0,0 +1,17 @@
+import { AlterTableStatement, CreateBulkCreateStoredProcedureStatement, CreateBulkDeleteStoredProcedureStatement, CreateBulkUpdateStoredProcedureStatement, CreateCreateStoredProcedureStatement, CreateDeleteStoredProcedureStatement, CreateReadStoredProcedureStatement, CreateTableStatement, CreateTriggerStatement, CreateUpdateStoredProcedureStatement, DropIndexStatement, DropRoutineStatement, IdentityInsertStatement, StatementRenderer, type StatementTextRenderer } from "@deterministic-code/datasources";
+export declare class SqlServerStatementRenderer extends StatementRenderer {
+    constructor(text: StatementTextRenderer);
+    protected visitCreateTable(create: CreateTableStatement): string;
+    protected visitAlterTable(alter: AlterTableStatement): string;
+    protected visitDropIndex(index: DropIndexStatement): string;
+    protected visitCreateTrigger(trigger: CreateTriggerStatement): string;
+    protected visitIdentityInsert(insert: IdentityInsertStatement): string;
+    protected visitDropRoutine(routine: DropRoutineStatement): string;
+    protected visitCreateCreateStoredProcedureStatement(statement: CreateCreateStoredProcedureStatement): string;
+    protected visitCreateReadStoredProcedureStatement(statement: CreateReadStoredProcedureStatement): string;
+    protected visitCreateUpdateStoredProcedureStatement(statement: CreateUpdateStoredProcedureStatement): string;
+    protected visitCreateDeleteStoredProcedureStatement(statement: CreateDeleteStoredProcedureStatement): string;
+    protected visitCreateBulkCreateStoredProcedureStatement(statement: CreateBulkCreateStoredProcedureStatement): string;
+    protected visitCreateBulkUpdateStoredProcedureStatement(statement: CreateBulkUpdateStoredProcedureStatement): string;
+    protected visitCreateBulkDeleteStoredProcedureStatement(statement: CreateBulkDeleteStoredProcedureStatement): string;
+}

package/dist/SqlServerStatementRenderer.js

@@ -0,0 +1,52 @@
+import { StatementRenderer, } from "@deterministic-code/datasources";
+import { SqlServerAlterTableStatementRenderer } from "./SqlServerAlterTableStatementRenderer.js";
+import { SqlServerCreateTableStatementRenderer } from "./SqlServerCreateTableStatementRenderer.js";
+import { SqlServerCreateTriggerStatementRenderer } from "./SqlServerCreateTriggerStatementRenderer.js";
+import { SqlServerDropIndexStatementRenderer } from "./SqlServerDropIndexStatementRenderer.js";
+import { SqlServerDropRoutineStatementRenderer } from "./SqlServerDropRoutineStatementRenderer.js";
+import { SqlServerStoredProcedureStatementRenderer } from "./SqlServerStoredProcedureStatementRenderer.js";
+import { SqlServerIdentityInsertStatementRenderer } from "./SqlServerIdentityInsertStatementRenderer.js";
+export class SqlServerStatementRenderer extends StatementRenderer {
+    constructor(text) {
+        super(text);
+    }
+    visitCreateTable(create) {
+        return new SqlServerCreateTableStatementRenderer().render(create);
+    }
+    visitAlterTable(alter) {
+        return new SqlServerAlterTableStatementRenderer().renderAlter(alter);
+    }
+    visitDropIndex(index) {
+        return new SqlServerDropIndexStatementRenderer().render(index);
+    }
+    visitCreateTrigger(trigger) {
+        return new SqlServerCreateTriggerStatementRenderer().render(trigger);
+    }
+    visitIdentityInsert(insert) {
+        return new SqlServerIdentityInsertStatementRenderer().render(insert);
+    }
+    visitDropRoutine(routine) {
+        return new SqlServerDropRoutineStatementRenderer().render(routine);
+    }
+    visitCreateCreateStoredProcedureStatement(statement) {
+        return new SqlServerStoredProcedureStatementRenderer().renderCreate(statement);
+    }
+    visitCreateReadStoredProcedureStatement(statement) {
+        return new SqlServerStoredProcedureStatementRenderer().renderRead(statement);
+    }
+    visitCreateUpdateStoredProcedureStatement(statement) {
+        return new SqlServerStoredProcedureStatementRenderer().renderUpdate(statement);
+    }
+    visitCreateDeleteStoredProcedureStatement(statement) {
+        return new SqlServerStoredProcedureStatementRenderer().renderDelete(statement);
+    }
+    visitCreateBulkCreateStoredProcedureStatement(statement) {
+        return new SqlServerStoredProcedureStatementRenderer().renderBulkCreate(statement);
+    }
+    visitCreateBulkUpdateStoredProcedureStatement(statement) {
+        return new SqlServerStoredProcedureStatementRenderer().renderBulkUpdate(statement);
+    }
+    visitCreateBulkDeleteStoredProcedureStatement(statement) {
+        return new SqlServerStoredProcedureStatementRenderer().renderBulkDelete(statement);
+    }
+}

package/dist/SqlServerStoredProcedureStatementRenderer.d.ts

@@ -0,0 +1,10 @@
+import type { CreateBulkCreateStoredProcedureStatement, CreateBulkDeleteStoredProcedureStatement, CreateBulkUpdateStoredProcedureStatement, CreateCreateStoredProcedureStatement, CreateDeleteStoredProcedureStatement, CreateReadStoredProcedureStatement, CreateUpdateStoredProcedureStatement } from "@deterministic-code/datasources";
+export declare class SqlServerStoredProcedureStatementRenderer {
+    renderCreate(statement: CreateCreateStoredProcedureStatement): string;
+    renderRead(statement: CreateReadStoredProcedureStatement): string;
+    renderUpdate(statement: CreateUpdateStoredProcedureStatement): string;
+    renderDelete(statement: CreateDeleteStoredProcedureStatement): string;
+    renderBulkCreate(statement: CreateBulkCreateStoredProcedureStatement): string;
+    renderBulkUpdate(statement: CreateBulkUpdateStoredProcedureStatement): string;
+    renderBulkDelete(statement: CreateBulkDeleteStoredProcedureStatement): string;
+}

package/dist/SqlServerStoredProcedureStatementRenderer.js

@@ -0,0 +1,112 @@
+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(", ");
+export class SqlServerStoredProcedureStatementRenderer {
+    renderCreate(statement) {
+        return `CREATE OR ALTER PROCEDURE ${statement.name}
+${params(statement.parameters)}
+AS
+BEGIN
+  INSERT INTO ${statement.table} (${statement.parameters.map((p) => p.name).join(", ")})
+  VALUES (${statement.parameters.map((p) => `@${p.name}`).join(", ")});
+  SELECT CAST(SCOPE_IDENTITY() AS BIGINT) AS ${statement.key};
+END;
+GO`;
+    }
+    renderRead(statement) {
+        const cols = statement.columns.join(", ");
+        if (statement.byProperties.length === 0) {
+            return `CREATE OR ALTER PROCEDURE ${statement.name}
+AS
+BEGIN
+  SELECT ${cols} FROM ${statement.table} ORDER BY ${statement.key};
+END;
+GO`;
+        }
+        const signature = statement.byProperties
+            .map((c) => `@${c} ${statement.parameters.find((p) => p.name === c)?.type ?? statement.keyType}`)
+            .join(", ");
+        const pred = statement.byProperties.map((c) => `${c} = @${c}`).join(" AND ");
+        return `CREATE OR ALTER PROCEDURE ${statement.name} ${signature}
+AS
+BEGIN
+  SELECT ${cols} FROM ${statement.table} WHERE ${pred};
+END;
+GO`;
+    }
+    renderUpdate(statement) {
+        const sets = statement.writable.map((c) => `    ${c} = @${c}`);
+        if (statement.auditUpdated !== undefined) {
+            const auditParam = statement.parameters.find((p) => p.name.includes("new_updated"));
+            if (auditParam)
+                sets.push(`    ${statement.auditUpdated} = @${auditParam.name}`);
+        }
+        const by = statement.byProperties.length > 0 ? statement.byProperties : [statement.key];
+        const pred = by.map((c) => `${c} = @${c}`).join(" AND ");
+        return `CREATE OR ALTER PROCEDURE ${statement.name}
+${params(statement.parameters)}
+AS
+BEGIN
+  UPDATE ${statement.table}
+  SET
+${sets.join(",\n")}
+  WHERE ${pred};
+  SELECT @@ROWCOUNT AS affected;
+END;
+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}`)
+            .join(", ");
+        const pred = by.map((c) => `${c} = @${c}`).join(" AND ");
+        return `CREATE OR ALTER PROCEDURE ${statement.name} ${signature}
+AS
+BEGIN
+  DELETE FROM ${statement.table} WHERE ${pred};
+  SELECT @@ROWCOUNT AS affected;
+END;
+GO`;
+    }
+    renderBulkCreate(statement) {
+        const cols = statement.columns.map((c) => c.name).join(", ");
+        return `CREATE OR ALTER PROCEDURE ${statement.name}
+  @${statement.payload.name} NVARCHAR(MAX),
+  @ids NVARCHAR(MAX) OUTPUT
+AS
+BEGIN
+  INSERT INTO ${statement.table} (${cols})
+  SELECT ${cols}
+  FROM OPENJSON(@${statement.payload.name}) WITH (${openjson(statement.columns)});
+  SET @ids = (SELECT ${statement.key} FROM ${statement.table} WHERE ${statement.key} >= SCOPE_IDENTITY() FOR JSON PATH);
+END;
+GO`;
+    }
+    renderBulkUpdate(statement) {
+        const sets = statement.columns
+            .filter((c) => c.name !== statement.key)
+            .map((c) => `t.${c.name} = payload_rows.${c.name}`)
+            .join(", ");
+        return `CREATE OR ALTER PROCEDURE ${statement.name}
+  @${statement.payload.name} NVARCHAR(MAX)
+AS
+BEGIN
+  UPDATE t SET ${sets}
+  FROM ${statement.table} t
+  JOIN OPENJSON(@${statement.payload.name}) WITH (${openjson(statement.columns)}) AS payload_rows
+    ON t.${statement.key} = payload_rows.${statement.key};
+END;
+GO`;
+    }
+    renderBulkDelete(statement) {
+        return `CREATE OR ALTER PROCEDURE ${statement.name}
+  @${statement.payload.name} NVARCHAR(MAX)
+AS
+BEGIN
+  DELETE t FROM ${statement.table} t
+  JOIN OPENJSON(@${statement.payload.name}) WITH (${statement.key} ${statement.keyType} '$.${statement.key}') AS payload_rows
+    ON t.${statement.key} = payload_rows.${statement.key};
+END;
+GO`;
+    }
+}

package/dist/connection.d.ts

@@ -0,0 +1,6 @@
+import { StubConnection, type DatasourceOptions, type ICommand } from "@deterministic-code/datasources";
+export declare class SqlServerConnection extends StubConnection {
+    constructor(_options?: DatasourceOptions);
+    createCommand: () => ICommand;
+    static from: (options?: DatasourceOptions) => SqlServerConnection;
+}

package/dist/connection.js

@@ -0,0 +1,8 @@
+import { StubCommand, StubConnection, } from "@deterministic-code/datasources";
+export class SqlServerConnection extends StubConnection {
+    constructor(_options) {
+        super("sqlserver");
+    }
+    createCommand = () => new StubCommand(this.provider, this);
+    static from = (options) => new SqlServerConnection(options);
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { SqlServerDriver } from "./SqlServerDriver.js";

package/dist/index.js

@@ -0,0 +1 @@
+export { SqlServerDriver } from "./SqlServerDriver.js";

package/package.json

@@ -1,6 +1,23 @@
 {
   "name": "@deterministic-code/datasources-sqlserver",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.2",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.js",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@deterministic-code/datasources": "^0.1.2"
+  }
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.