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

package/dist/sql-server-row.js

@@ -0,0 +1,25 @@
+export class SqlServerRow {
+    table;
+    // One value per readable column, in the table's column order.
+    values;
+    constructor(table, values) {
+        this.table = table;
+        this.values = values;
+        Object.freeze(this);
+    }
+    value(column) {
+        const index = this.table.columns.indexOf(column);
+        if (index === -1)
+            throw new TypeError(`${this.table.quoted} has no column ${column.name}`);
+        return this.values[index] ?? null;
+    }
+    // Where this row sits in primary key order, as text a page reads after.
+    get position() {
+        return this.table.primaryKey.map((column) => {
+            const value = this.value(column);
+            if (value === null)
+                throw new TypeError(`${this.table.quoted} key ${column.name} is null`);
+            return column.codec.position(value);
+        });
+    }
+}

package/dist/sql-server-session.d.ts

@@ -0,0 +1,24 @@
+import sql from 'mssql';
+import { type ChangePosition, ChangeSet } from './change-set.ts';
+import { SqlServerRow } from './sql-server-row.ts';
+import { SqlServerTable } from './sql-server-table.ts';
+export type SqlServerVersion = {
+    readonly changeTracking: string | null;
+    readonly rowversion: string;
+};
+export declare class SqlServerSession implements AsyncDisposable {
+    #private;
+    constructor(pool: sql.ConnectionPool, location: string, snapshotIsolation: boolean);
+    [Symbol.asyncDispose](): Promise<void>;
+    tables(): Promise<SqlServerTable[]>;
+    version(): Promise<SqlServerVersion>;
+    statistics(): Promise<ReadonlyMap<string, string>>;
+    rowCounts(): Promise<ReadonlyMap<string, string>>;
+    lastWrites(): Promise<ReadonlyMap<string, string>>;
+    changeTrackingPosition(table: SqlServerTable): Promise<ChangePosition>;
+    minActiveRowversion(): Promise<string>;
+    page(table: SqlServerTable, after: readonly string[] | null, limit: number): AsyncGenerator<SqlServerRow>;
+    rowversions(table: SqlServerTable, above: string, below: string, limit: number): AsyncGenerator<SqlServerRow>;
+    rows(table: SqlServerTable): AsyncGenerator<SqlServerRow>;
+    changes(table: SqlServerTable, since: ChangePosition): Promise<ChangeSet>;
+}

package/dist/sql-server-session.js

@@ -0,0 +1,374 @@
+import sql from 'mssql';
+import { cellBoolean, cellNullableText, cellNumber, cellText, } from './cells.js';
+import { ChangeSet, } from './change-set.js';
+import { codecFor, declaredType } from './codecs/codec-for.js';
+import { ChangeHistoryExpiredError, SqlServerPermissionError, } from './errors.js';
+import { SqlServerColumn } from './sql-server-column.js';
+import { query, stream } from './sql-server-request.js';
+import { SqlServerRow } from './sql-server-row.js';
+import { SqlServerTable } from './sql-server-table.js';
+// User tables only: not the system's own, not external tables (their rows
+// live elsewhere), and not the change tables CDC keeps.
+const tablesQuery = `
+SELECT t.object_id, s.name, t.name,
+  CONVERT(nvarchar(max), ep.value),
+  CASE
+    WHEN ctt.object_id IS NULL THEN 'off'
+    WHEN HAS_PERMS_BY_NAME(QUOTENAME(s.name) + '.' + QUOTENAME(t.name), 'OBJECT', 'VIEW CHANGE TRACKING') = 1 THEN 'readable'
+    ELSE 'denied'
+  END
+FROM sys.tables AS t
+JOIN sys.schemas AS s ON s.schema_id = t.schema_id
+LEFT JOIN sys.extended_properties AS ep
+  ON ep.class = 1 AND ep.major_id = t.object_id AND ep.minor_id = 0 AND ep.name = 'MS_Description'
+LEFT JOIN sys.change_tracking_tables AS ctt ON ctt.object_id = t.object_id
+WHERE t.is_ms_shipped = 0 AND t.is_external = 0 AND s.name <> 'cdc'
+ORDER BY s.name, t.name`;
+// For each table: how many statistics it has, the rows changed in their
+// columns since each was last refreshed, and the last refresh.
+const statisticsQuery = `
+SELECT QUOTENAME(SCHEMA_NAME(t.schema_id)) + '.' + QUOTENAME(t.name),
+  CONCAT(COUNT(p.stats_id), ' ', SUM(p.modification_counter), ' ', CONVERT(varchar(27), MAX(p.last_updated), 126))
+FROM sys.tables AS t
+LEFT JOIN sys.stats AS st ON st.object_id = t.object_id
+OUTER APPLY sys.dm_db_stats_properties(st.object_id, st.stats_id) AS p
+GROUP BY t.schema_id, t.name`;
+// For each table: the rows of its heap or clustered index, in every
+// partition.
+const rowCountsQuery = `
+SELECT QUOTENAME(SCHEMA_NAME(t.schema_id)) + '.' + QUOTENAME(t.name),
+  CONVERT(varchar(20), SUM(p.rows))
+FROM sys.tables AS t
+JOIN sys.partitions AS p ON p.object_id = t.object_id AND p.index_id IN (0, 1)
+GROUP BY t.schema_id, t.name`;
+// For each table: the writes counted on its indexes since the engine
+// started, and the last. A table with no usage row yet counts 0 writes, as
+// it does after the first read makes its row, so a read moves nothing.
+const lastWritesQuery = `
+SELECT QUOTENAME(SCHEMA_NAME(t.schema_id)) + '.' + QUOTENAME(t.name),
+  CONCAT(COALESCE(SUM(u.user_updates), 0), ' ', CONVERT(varchar(23), MAX(u.last_user_update), 126))
+FROM sys.tables AS t
+LEFT JOIN sys.dm_db_index_usage_stats AS u
+  ON u.object_id = t.object_id AND u.database_id = DB_ID()
+GROUP BY t.schema_id, t.name`;
+// TYPE_NAME(system_type_id) is the system type an alias type is built on; a
+// login that cannot see an alias type would otherwise lose its columns. CLR
+// types share one system type, so they keep their own name.
+const columnsQuery = `
+SELECT c.object_id, c.name, COALESCE(TYPE_NAME(c.system_type_id), ty.name),
+  CAST(COALESCE(ty.is_assembly_type, CASE WHEN c.system_type_id = 240 THEN 1 ELSE 0 END) AS bit),
+  CAST(c.max_length AS int), CAST(c.precision AS int), CAST(c.scale AS int),
+  c.is_nullable, c.is_masked, c.collation_name,
+  CONVERT(nvarchar(max), ep.value),
+  HAS_PERMS_BY_NAME(QUOTENAME(OBJECT_SCHEMA_NAME(c.object_id)) + '.' + QUOTENAME(OBJECT_NAME(c.object_id)), 'OBJECT', 'SELECT', c.name, 'COLUMN')
+FROM sys.columns AS c
+JOIN sys.tables AS t ON t.object_id = c.object_id
+LEFT JOIN sys.types AS ty ON ty.user_type_id = c.user_type_id
+LEFT JOIN sys.extended_properties AS ep
+  ON ep.class = 1 AND ep.major_id = c.object_id AND ep.minor_id = c.column_id AND ep.name = 'MS_Description'
+WHERE t.is_ms_shipped = 0
+ORDER BY c.object_id, c.column_id`;
+// A table's tracking generation. A truncate starts its history over at the
+// current version (begin_version) and re-enabling tracking recreates its
+// change table (create_date); either way the changes before it are gone, and
+// the minimum valid version alone does not show it when nothing else changed.
+const generationQuery = `(SELECT CONVERT(varchar(20), ctt.begin_version) + '@' + CONVERT(varchar(30), it.create_date, 126)
+  FROM sys.change_tracking_tables AS ctt
+  JOIN sys.internal_tables AS it ON it.parent_object_id = ctt.object_id AND it.internal_type_desc = 'CHANGE_TRACKING'
+  WHERE ctt.object_id = OBJECT_ID(@p0))`;
+const primaryKeysQuery = `
+SELECT ic.object_id, c.name
+FROM sys.indexes AS i
+JOIN sys.index_columns AS ic ON ic.object_id = i.object_id AND ic.index_id = i.index_id
+JOIN sys.columns AS c ON c.object_id = ic.object_id AND c.column_id = ic.column_id
+WHERE i.is_primary_key = 1
+ORDER BY ic.object_id, ic.key_ordinal`;
+// One run's connections to the database. Reads hold no transaction between
+// statements, except one short snapshot transaction around a Change
+// Tracking delta when the database allows snapshot isolation.
+export class SqlServerSession {
+    #pool;
+    #location;
+    // ALLOW_SNAPSHOT_ISOLATION is on, so a delta can read in one snapshot.
+    #snapshot;
+    constructor(pool, location, snapshotIsolation) {
+        this.#pool = pool;
+        this.#location = location;
+        this.#snapshot = snapshotIsolation;
+        Object.freeze(this);
+    }
+    async [Symbol.asyncDispose]() {
+        await this.#pool.close();
+    }
+    // Every user table, with the columns, primary key and Change Tracking the
+    // login can read.
+    async tables() {
+        const [tables, columns, keys] = await Promise.all([
+            query(this.#pool.request(), tablesQuery),
+            query(this.#pool.request(), columnsQuery),
+            query(this.#pool.request(), primaryKeysQuery),
+        ]);
+        const columnsOf = groupBy(columns);
+        const keysOf = groupBy(keys);
+        return tables.map(([id, schema, name, description, changeTracking]) => {
+            const readable = [];
+            const unreadable = [];
+            for (const row of columnsOf.get(cellNumber(id, 'object_id')) ?? []) {
+                const [, columnName, typeName, clr, maxLength, precision, scale, nullable, masked, collation, comment, granted,] = row;
+                const type = {
+                    name: cellNullableText(typeName, 'type'),
+                    clr: cellBoolean(clr, 'is_assembly_type'),
+                    maxLength: cellNumber(maxLength, 'max_length'),
+                    precision: cellNumber(precision, 'precision'),
+                    scale: cellNumber(scale, 'scale'),
+                    collation: cellNullableText(collation, 'collation_name'),
+                };
+                const column = cellText(columnName, 'column name');
+                if (granted !== 1) {
+                    unreadable.push(column);
+                    continue;
+                }
+                readable.push(new SqlServerColumn({
+                    name: column,
+                    type: declaredType(type),
+                    nullable: cellBoolean(nullable, 'is_nullable'),
+                    masked: cellBoolean(masked, 'is_masked'),
+                    description: cellNullableText(comment, 'MS_Description'),
+                    codec: codecFor(type),
+                }));
+            }
+            const keyNames = (keysOf.get(cellNumber(id, 'object_id')) ?? []).map(([, key]) => cellText(key, 'key column'));
+            const primaryKey = keyNames.flatMap((key) => readable.find((column) => column.name === key) ?? []);
+            return new SqlServerTable({
+                schema: cellText(schema, 'schema'),
+                name: cellText(name, 'table'),
+                description: cellNullableText(description, 'MS_Description'),
+                columns: readable,
+                unreadable,
+                // A key the login cannot read in full cannot identify rows.
+                primaryKey: primaryKey.length === keyNames.length ? primaryKey : [],
+                changeTracking: trackingState(cellText(changeTracking, 'change tracking')),
+            });
+        });
+    }
+    async version() {
+        const [[changeTracking, rowversion] = []] = await query(this.#pool.request(), 'SELECT CONVERT(varchar(20), CHANGE_TRACKING_CURRENT_VERSION()), CONVERT(varchar(20), CAST(@@DBTS AS bigint))');
+        return Object.freeze({
+            changeTracking: cellNullableText(changeTracking, 'change tracking version'),
+            rowversion: cellText(rowversion, '@@DBTS'),
+        });
+    }
+    // Where the statistics of each table stand, by its quoted name: SQL Server
+    // counts the rows changed in each column that has statistics, and keeps the
+    // count through a restart. A refresh of statistics sets their count back to
+    // 0, so the value carries the time of the last refresh too. A table with no
+    // statistics has no count, so its value never moves. A login that can read
+    // a table can read its counts.
+    async statistics() {
+        const rows = await query(this.#pool.request(), statisticsQuery);
+        return new Map(rows.map(([table, counts]) => [
+            cellText(table, 'table'),
+            cellText(counts, 'statistics'),
+        ]));
+    }
+    // How many rows each table holds, by its quoted name, as SQL Server keeps
+    // it in the table's metadata: an insert, a delete or a TRUNCATE moves it,
+    // also in a table whose statistics SQL Server has not built, but an update
+    // does not. A login that can read a table can read its count.
+    async rowCounts() {
+        const rows = await query(this.#pool.request(), rowCountsQuery);
+        return new Map(rows.map(([table, count]) => [
+            cellText(table, 'table'),
+            cellText(count, 'row count'),
+        ]));
+    }
+    // When SQL Server last wrote to each table, by its quoted name, and how
+    // many writes it counted: any insert, update or delete moves it, also of a
+    // column with no statistics, but not a TRUNCATE. A restart forgets both,
+    // so the value of each table is then empty. A login needs VIEW SERVER
+    // STATE to read them (VIEW DATABASE STATE on Azure SQL Database).
+    async lastWrites() {
+        const rows = await query(this.#pool.request(), lastWritesQuery).catch((error) => {
+            // 297: the login may not read the state of the server or database.
+            if (error instanceof sql.RequestError && error.number === 297)
+                throw new SqlServerPermissionError('VIEW SERVER STATE (VIEW DATABASE STATE on Azure SQL Database)', error);
+            throw error;
+        });
+        return new Map(rows.map(([table, writes]) => [
+            cellText(table, 'table'),
+            cellText(writes, 'last write'),
+        ]));
+    }
+    // Where a full read of the table starts in its change history: read it
+    // before the rows, so a change made during the read is read again, never
+    // missed.
+    async changeTrackingPosition(table) {
+        const [[version, generation] = []] = await query(this.#pool.request(), `SELECT CONVERT(varchar(20), CHANGE_TRACKING_CURRENT_VERSION()), ${generationQuery}`, [table.quoted]);
+        if (version === null || generation === null)
+            throw new TypeError(`Change Tracking is off for ${table.quoted} in ${this.#location}`);
+        return Object.freeze({
+            version: cellText(version, 'change tracking version'),
+            generation: cellText(generation, 'change tracking generation'),
+        });
+    }
+    // Rows below this rowversion are committed; one at or above it may belong
+    // to a transaction still open, so a read stops short of it.
+    async minActiveRowversion() {
+        const [[value] = []] = await query(this.#pool.request(), 'SELECT CONVERT(varchar(20), CAST(MIN_ACTIVE_ROWVERSION() AS bigint))');
+        return cellText(value, 'MIN_ACTIVE_ROWVERSION');
+    }
+    // Up to limit rows in primary key order, after the given position. The
+    // whole key compares as a tuple, each part cast to its column's type, so
+    // pages neither skip nor repeat rows that share a leading key value.
+    async *page(table, after, limit) {
+        if (!table.pageable)
+            throw new TypeError(`${table.quoted} has no primary key a read can page by`);
+        const keys = table.primaryKey;
+        const key = (index) => `t.${keys[index]?.quoted}`;
+        const cast = (index) => keys[index]?.codec.cast(`@p${index}`);
+        const where = after === null
+            ? ''
+            : `WHERE ${keys
+                .map((_, index) => `(${[
+                ...keys
+                    .slice(0, index)
+                    .map((__, prior) => `${key(prior)} = ${cast(prior)}`),
+                `${key(index)} > ${cast(index)}`,
+            ].join(' AND ')})`)
+                .join(' OR ')}`;
+        yield* this.#rows(table, `SELECT TOP (${count(limit)}) ${selection(table)} FROM ${table.quoted} AS t ${where} ORDER BY ${keys.map((_, index) => key(index)).join(', ')}`, after ?? []);
+    }
+    // Up to limit rows whose rowversion is above `above` and below `below`, in
+    // rowversion order.
+    async *rowversions(table, above, below, limit) {
+        const column = table.rowversion;
+        if (column === undefined)
+            throw new TypeError(`${table.quoted} has no rowversion column`);
+        const version = `t.${column.quoted}`;
+        yield* this.#rows(table, `SELECT TOP (${count(limit)}) ${selection(table)} FROM ${table.quoted} AS t WHERE ${version} > ${column.codec.cast('@p0')} AND ${version} < ${column.codec.cast('@p1')} ORDER BY ${version}`, [above, below]);
+    }
+    // Every row, in no particular order.
+    async *rows(table) {
+        yield* this.#rows(table, `SELECT ${selection(table)} FROM ${table.quoted} AS t`, []);
+    }
+    // What changed in the table since a position in its change history: each
+    // changed key once, with its row as it is now, or as a deletion. A position
+    // from another generation, at the start of its generation, or outside the
+    // history kept, has expired. With snapshot isolation the version, the check
+    // and the changes come from one snapshot. Without it the version is read
+    // first, so a change made during the read is read again next time, and the
+    // check runs again after the read in case cleanup removed history
+    // meanwhile.
+    async changes(table, since) {
+        if (table.primaryKey.length === 0)
+            throw new TypeError(`${table.quoted} has no primary key to track changes by`);
+        const transaction = this.#snapshot
+            ? new sql.Transaction(this.#pool)
+            : undefined;
+        await transaction?.begin(sql.ISOLATION_LEVEL.SNAPSHOT);
+        let open = transaction !== undefined;
+        const close = async () => {
+            if (!open)
+                return;
+            open = false;
+            await transaction?.rollback();
+        };
+        const request = () => transaction === undefined
+            ? this.#pool.request()
+            : new sql.Request(transaction);
+        const check = async () => {
+            const [[current, minimum, viewable, generation, begin] = []] = await query(request(), `SELECT CONVERT(varchar(20), CHANGE_TRACKING_CURRENT_VERSION()), CONVERT(varchar(20), CHANGE_TRACKING_MIN_VALID_VERSION(OBJECT_ID(@p0))), HAS_PERMS_BY_NAME(@p0, 'OBJECT', 'VIEW CHANGE TRACKING'), ${generationQuery}, (SELECT CONVERT(varchar(20), begin_version) FROM sys.change_tracking_tables WHERE object_id = OBJECT_ID(@p0))`, [table.quoted]);
+            // Without the grant SQL Server still reports a minimum valid version
+            // (0), so the grant itself is checked first.
+            if (viewable !== 1)
+                throw new SqlServerPermissionError(`VIEW CHANGE TRACKING ON ${table.quoted}`);
+            if (minimum === null || generation === null)
+                throw new TypeError(`Change Tracking is off for ${table.quoted}`);
+            const version = cellText(current, 'change tracking version');
+            // A TRUNCATE moves begin_version to the current version. When the
+            // generation began at the saved version, a truncate since moves it
+            // nowhere, so such a position cannot show one.
+            if (generation !== since.generation ||
+                BigInt(since.version) <= BigInt(cellText(begin, 'begin version')) ||
+                BigInt(since.version) <
+                    BigInt(cellText(minimum, 'minimum valid version')) ||
+                BigInt(since.version) > BigInt(version))
+                throw new ChangeHistoryExpiredError(table.quoted, since.version);
+            return version;
+        };
+        try {
+            const version = await check();
+            const keys = table.primaryKey;
+            const present = `CASE WHEN t.${keys[0]?.quoted} IS NULL THEN 0 ELSE 1 END`;
+            const changed = keys.flatMap((column) => column.codec.select(`ct.${column.quoted}`));
+            const text = `DECLARE @since bigint = CAST(@p0 AS bigint);
+SELECT ${present}, ${changed.join(', ')}, ${selection(table)}
+FROM CHANGETABLE(CHANGES ${table.quoted}, @since) AS ct
+LEFT JOIN ${table.quoted} AS t ON ${keys.map((column) => `t.${column.quoted} = ct.${column.quoted}`).join(' AND ')}`;
+            const changes = async function* () {
+                for await (const values of stream(request(), text, [since.version])) {
+                    const [exists] = values;
+                    const key = decode(keys, values.slice(1, 1 + changed.length));
+                    yield exists === 1
+                        ? {
+                            type: 'upsert',
+                            row: new SqlServerRow(table, decode(table.columns, values.slice(1 + changed.length))),
+                        }
+                        : { type: 'delete', key };
+                }
+                if (transaction === undefined)
+                    await check();
+                else {
+                    open = false;
+                    await transaction.commit();
+                }
+            };
+            // A read stopped early, or failed, leaves the snapshot to roll back.
+            return new ChangeSet(Object.freeze({ version, generation: since.generation }), changes(), close);
+        }
+        catch (error) {
+            await close();
+            throw error;
+        }
+    }
+    async *#rows(table, text, parameters) {
+        for await (const values of stream(this.#pool.request(), text, parameters))
+            yield new SqlServerRow(table, decode(table.columns, values));
+    }
+}
+function trackingState(value) {
+    if (value === 'off' || value === 'readable' || value === 'denied')
+        return value;
+    throw new TypeError(`Unknown Change Tracking state ${value}`);
+}
+function count(limit) {
+    if (!Number.isSafeInteger(limit) || limit < 1)
+        throw new TypeError(`A page holds at least one row, not ${limit}`);
+    return limit;
+}
+// The expressions that read every column exactly, in column order.
+function selection(table) {
+    return table.columns
+        .flatMap((column) => column.codec.select(`t.${column.quoted}`))
+        .join(', ');
+}
+// Each column's value from the expressions its codec selected.
+function decode(columns, values) {
+    let offset = 0;
+    return columns.map(({ codec }) => {
+        const width = codec.select('x').length;
+        const value = codec.decode(values.slice(offset, offset + width));
+        offset += width;
+        return value;
+    });
+}
+function groupBy(rows) {
+    const groups = new Map();
+    for (const row of rows) {
+        const id = cellNumber(row[0], 'object_id');
+        const group = groups.get(id) ?? [];
+        group.push(row);
+        groups.set(id, group);
+    }
+    return groups;
+}

package/dist/sql-server-table.d.ts

@@ -0,0 +1,23 @@
+import type { SqlServerColumn } from './sql-server-column.ts';
+export type ChangeTracking = 'off' | 'readable' | 'denied';
+export declare class SqlServerTable {
+    readonly schema: string;
+    readonly name: string;
+    readonly description: string | null;
+    readonly columns: readonly SqlServerColumn[];
+    readonly unreadable: readonly string[];
+    readonly primaryKey: readonly SqlServerColumn[];
+    readonly changeTracking: ChangeTracking;
+    constructor(table: {
+        schema: string;
+        name: string;
+        description: string | null;
+        columns: readonly SqlServerColumn[];
+        unreadable: readonly string[];
+        primaryKey: readonly SqlServerColumn[];
+        changeTracking: ChangeTracking;
+    });
+    get quoted(): string;
+    get rowversion(): SqlServerColumn | undefined;
+    get pageable(): boolean;
+}

package/dist/sql-server-table.js

@@ -0,0 +1,36 @@
+import { quoteName } from './quote-name.js';
+export class SqlServerTable {
+    schema;
+    name;
+    // Its MS_Description extended property.
+    description;
+    // The columns the login can read, in their declared order.
+    columns;
+    // The columns a column-level DENY keeps from the login.
+    unreadable;
+    // Empty when the table has no primary key, or the login cannot read all of it.
+    primaryKey;
+    changeTracking;
+    constructor(table) {
+        this.schema = table.schema;
+        this.name = table.name;
+        this.description = table.description;
+        this.columns = Object.freeze([...table.columns]);
+        this.unreadable = Object.freeze([...table.unreadable]);
+        this.primaryKey = Object.freeze([...table.primaryKey]);
+        this.changeTracking = table.changeTracking;
+        Object.freeze(this);
+    }
+    get quoted() {
+        return `${quoteName(this.schema)}.${quoteName(this.name)}`;
+    }
+    // The rowversion column, which SQL Server sets on every insert and update.
+    get rowversion() {
+        return this.columns.find((column) => column.type === 'timestamp');
+    }
+    // Whether reads can page through the table in primary key order.
+    get pageable() {
+        return (this.primaryKey.length > 0 &&
+            this.primaryKey.every((column) => column.codec.cast('@p') !== undefined));
+    }
+}

package/dist/values.d.ts

@@ -0,0 +1,11 @@
+export declare class OffsetTimestamp {
+    readonly instant: string;
+    readonly offset: number;
+    constructor(instant: string, offset: number);
+}
+export declare class VariantValue {
+    readonly text: string;
+    readonly type: string;
+    constructor(text: string, type: string);
+}
+export type SqlServerValue = string | number | boolean | OffsetTimestamp | VariantValue | null;

package/dist/values.js

@@ -0,0 +1,22 @@
+// A datetimeoffset value: its UTC instant, and the offset in minutes it was
+// written with, which the instant alone loses.
+export class OffsetTimestamp {
+    instant;
+    offset;
+    constructor(instant, offset) {
+        this.instant = instant;
+        this.offset = offset;
+        Object.freeze(this);
+    }
+}
+// A sql_variant value: its text, and the base type it holds, which decides
+// how to read the text.
+export class VariantValue {
+    text;
+    type;
+    constructor(text, type) {
+        this.text = text;
+        this.type = type;
+        Object.freeze(this);
+    }
+}

package/package.json

@@ -1,6 +1,48 @@
 {
   "name": "@eltjs/sdk-microsoft-sql-server",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Reads one SQL Server database: discovery, exact reads, Change Tracking and change signals. It knows nothing of elt.",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ezzabuzaid/elt",
+    "directory": "packages/sdks/microsoft/sql-server"
+  },
+  "bugs": {
+    "url": "https://github.com/ezzabuzaid/elt/issues"
+  },
+  "homepage": "https://github.com/ezzabuzaid/elt/tree/main/packages/sdks/microsoft/sql-server#readme",
+  "keywords": [
+    "sql-server",
+    "mssql",
+    "azure-sql",
+    "change-tracking"
+  ],
+  "type": "module",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!dist/spec/**",
+    "!**/*.tsbuildinfo",
+    "!**/*.test.*"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "dependencies": {
+    "@types/mssql": "^12.3.0",
+    "mssql": "^12.7.4"
+  },
+  "devDependencies": {
+    "@zukhruf/testing": "^0.8.10"
+  }
+}