@eltjs/source-microsoft-sql-server 0.0.0-stage → 0.1.0

package/dist/watch-gauges.js

@@ -0,0 +1,132 @@
+import { Collector, Latch, Period, } from '@zukhruf/async';
+// A value of each table, by its quoted name, from one query.
+class TableValues extends Collector {
+    #read;
+    constructor(read) {
+        super();
+        this.#read = read;
+    }
+    collect() {
+        return this.#read();
+    }
+}
+// The two versions of the database, from one query.
+class DatabaseVersion extends Collector {
+    #session;
+    constructor(session) {
+        super();
+        this.#session = session;
+    }
+    async collect() {
+        const { changeTracking, rowversion } = await (await this.#session.open()).version();
+        return new Map([
+            ['changeTracking', changeTracking],
+            ['rowversion', rowversion],
+        ]);
+    }
+}
+// The gauges of one watch, over one session that the first read that needs it
+// opens, so a refused login fails the gauges of that check, not the watch. A
+// collector reads in a check only when a watched stream names one of its
+// gauges.
+export class WatchGauges {
+    // The statistics of each table: SQL Server counts the rows that an insert,
+    // a delete, a TRUNCATE or an update of a column with statistics changes,
+    // and keeps the count through a restart. An update of a column with no
+    // statistics moves nothing.
+    statistics;
+    // How many rows each table holds: an insert, a delete or a TRUNCATE moves
+    // it, also in a table whose statistics SQL Server has not built yet, which
+    // count nothing, and in a tracked table, whose Change Tracking version a
+    // TRUNCATE does not move. An update moves nothing.
+    rowCounts;
+    // When SQL Server last wrote to each table: any insert, update or delete
+    // moves it, also of a column with no statistics.
+    lastWrites;
+    // The database's last committed Change Tracking version: each change to a
+    // tracked table moves it, in the transaction of the change. A TRUNCATE
+    // does not.
+    changeTracking;
+    // The database's last rowversion (@@DBTS): each insert or update of a row
+    // with a rowversion column moves it.
+    rowversion;
+    // The whole hours since the watch started: a stream that names it reloads
+    // once an hour, which finds a change that its other gauges cannot see.
+    hour = new Period(60 * 60_000);
+    #session;
+    constructor(database) {
+        const session = new WatchSession(database);
+        this.#session = session;
+        this.statistics = new TableValues(async () => (await session.open()).statistics());
+        this.rowCounts = new TableValues(async () => (await session.open()).rowCounts());
+        this.lastWrites = new TableValues(async () => (await session.open()).lastWrites());
+        const version = new DatabaseVersion(session);
+        this.changeTracking = version.gauge('changeTracking');
+        this.rowversion = version.gauge('rowversion');
+    }
+    [Symbol.asyncDispose]() {
+        return this.#session[Symbol.asyncDispose]();
+    }
+}
+// The session of one watch. An open that fails, for example because the
+// server cannot be reached now, leaves it closed, so the next check opens it
+// again.
+class WatchSession {
+    #database;
+    #state;
+    constructor(database) {
+        this.#database = database;
+        this.#state = new Closed(database);
+    }
+    // The reads of one check share one open.
+    open() {
+        const state = this.#state.open(() => {
+            if (this.#state === state)
+                this.#state = new Closed(this.#database);
+        });
+        this.#state = state;
+        return state.session();
+    }
+    // Each stream's gauge of the watch closes the session when the pipeline
+    // disposes it: the first one closes it, and the others find it closed.
+    async [Symbol.asyncDispose]() {
+        const state = this.#state;
+        this.#state = new Closed(this.#database);
+        await state[Symbol.asyncDispose]();
+    }
+}
+class Closed {
+    #database;
+    constructor(database) {
+        this.#database = database;
+    }
+    open(failed) {
+        return new Opening(this.#database, failed);
+    }
+    // Nothing is open.
+    async [Symbol.asyncDispose]() { }
+}
+class Opening {
+    #opened = new Latch();
+    constructor(database, failed) {
+        database.open().then((value) => this.#opened.open({ status: 'fulfilled', value }), (reason) => {
+            failed();
+            this.#opened.open({ status: 'rejected', reason });
+        });
+    }
+    open() {
+        return this;
+    }
+    async session() {
+        const opened = await this.#opened.wait();
+        if (opened.status === 'rejected')
+            throw opened.reason;
+        return opened.value;
+    }
+    // An open that failed has nothing to close; its gauges gave its error.
+    async [Symbol.asyncDispose]() {
+        const opened = await this.#opened.wait();
+        if (opened.status === 'fulfilled')
+            await opened.value[Symbol.asyncDispose]();
+    }
+}

package/dist/whole-table-gauges.d.ts

@@ -0,0 +1,10 @@
+import type { Gauge } from '@zukhruf/async';
+import { type SqlServerSession, type SqlServerTable } from '@eltjs/sdk-microsoft-sql-server';
+import type { WatchGauges } from './watch-gauges.ts';
+export declare class WholeTableGauges {
+    #private;
+    readonly hint: string;
+    private constructor();
+    static discover(session: SqlServerSession): Promise<WholeTableGauges>;
+    gauges(table: SqlServerTable, watch: WatchGauges): readonly Gauge[];
+}

package/dist/whole-table-gauges.js

@@ -0,0 +1,31 @@
+import { SqlServerPermissionError, } from '@eltjs/sdk-microsoft-sql-server';
+// The gauges of a stream that reads its whole table: its statistics, its
+// row count, when the login may read them its last write, and the hour.
+// Without the last write, an update of a column with no statistics waits for
+// the hour, and hint says which grant would wake the stream at once.
+export class WholeTableGauges {
+    hint;
+    #collectors;
+    constructor(collectors, hint) {
+        this.#collectors = collectors;
+        this.hint = hint;
+    }
+    // Tries to read the last writes once, as a watch would.
+    static async discover(session) {
+        try {
+            await session.lastWrites();
+            return new WholeTableGauges(['statistics', 'rowCounts', 'lastWrites'], '');
+        }
+        catch (error) {
+            if (!(error instanceof SqlServerPermissionError))
+                throw error;
+            return new WholeTableGauges(['statistics', 'rowCounts'], ` Granting the login ${error.grant} would wake a watch on any write, also to a column with no statistics.`);
+        }
+    }
+    gauges(table, watch) {
+        return [
+            ...this.#collectors.map((name) => watch[name].gauge(table.quoted)),
+            watch.hour,
+        ];
+    }
+}

package/package.json

@@ -1,6 +1,61 @@
 {
   "name": "@eltjs/source-microsoft-sql-server",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "An elt source for one SQL Server database: each user table that the login can read becomes a stream.",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ezzabuzaid/elt",
+    "directory": "packages/sources/microsoft/sql-server"
+  },
+  "bugs": {
+    "url": "https://github.com/ezzabuzaid/elt/issues"
+  },
+  "homepage": "https://github.com/ezzabuzaid/elt/tree/main/packages/sources/microsoft/sql-server#readme",
+  "keywords": [
+    "elt",
+    "sql-server",
+    "mssql",
+    "azure-sql",
+    "source",
+    "change-tracking"
+  ],
+  "type": "module",
+  "exports": {
+    "./package.json": "./package.json",
+    "./sql-server-copies": {
+      "types": "./dist/sql-server-copies.d.ts",
+      "default": "./dist/sql-server-copies.js"
+    },
+    "./sql-server-source": {
+      "types": "./dist/sql-server-source.d.ts",
+      "default": "./dist/sql-server-source.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!dist/spec/**",
+    "!**/*.tsbuildinfo",
+    "!**/*.test.*"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "dependencies": {
+    "@eltjs/elt": "^0.1.0",
+    "@eltjs/sdk-microsoft-sql-server": "^0.1.0",
+    "@zukhruf/async": "^0.8.10",
+    "@zukhruf/snapshot-differential": "^0.8.10"
+  },
+  "devDependencies": {
+    "@sinonjs/fake-timers": "15.4.0",
+    "@types/mssql": "^12.3.0",
+    "@eltjs/elt-postgresql": "0.0.1",
+    "@zukhruf/testing": "^0.8.10",
+    "mssql": "^12.7.4",
+    "postgres": "^3.4.9"
+  }
+}