@remix-run/data-table 0.0.0 → 0.2.0

package/dist/lib/database.js

@@ -0,0 +1,319 @@
+import { DataTableAdapterError, DataTableQueryError } from "./errors.js";
+import { executeOperation } from "./database/execution-context.js";
+import { asQueryTableInput, getPrimaryKeyWhere, getPrimaryKeyWhereFromRow, normalizeOrderByInput, resolveCreateRowWhere, toWriteResult, } from "./database/helpers.js";
+import { executeQuery } from "./database/query-execution.js";
+import { bindQueryRuntime, query as createQuery } from "./query.js";
+import { isSqlStatement, rawSql } from "./sql.js";
+import { getTableName } from "./table.js";
+const createInternalDatabase = Symbol('createInternalDatabase');
+/**
+ * High-level database runtime used to build and execute data manipulation operations.
+ *
+ * Create instances directly with `new Database(adapter, options)` or use
+ * `createDatabase(adapter, options)` as a thin wrapper.
+ */
+export class Database {
+    #adapter;
+    #token;
+    #now;
+    #savepointCounter;
+    constructor(adapter, options) {
+        this.#adapter = adapter;
+        this.#now = options?.now ?? defaultNow;
+        this.#savepointCounter = { value: 0 };
+    }
+    static [createInternalDatabase](adapter, options, internal) {
+        let database = new Database(adapter, options);
+        database.#token = internal.token;
+        database.#savepointCounter = internal.savepointCounter;
+        return database;
+    }
+    get adapter() {
+        return this.#adapter;
+    }
+    now() {
+        return this.#now();
+    }
+    query(table) {
+        return createQuery(table)[bindQueryRuntime](this);
+    }
+    async create(table, values, options) {
+        let touch = options?.touch;
+        let query = this.query(asQueryTableInput(table));
+        if (options?.returnRow !== true) {
+            let result = await query.insert(values, { touch });
+            return toWriteResult(result);
+        }
+        if (this.#adapter.capabilities.returning) {
+            let result = (await query.insert(values, {
+                returning: '*',
+                touch,
+            }));
+            let row = result.row;
+            if (!row) {
+                throw new DataTableQueryError('create({ returnRow: true }) failed to return an inserted row');
+            }
+            if (!options.with) {
+                return row;
+            }
+            let where = getPrimaryKeyWhereFromRow(table, row);
+            let loaded = await this.findOne(table, {
+                where,
+                with: options.with,
+            });
+            if (!loaded) {
+                throw new DataTableQueryError('create({ returnRow: true }) failed to load inserted row');
+            }
+            return loaded;
+        }
+        let insertResult = await query.insert(values, { touch });
+        let where = resolveCreateRowWhere(table, values, toWriteResult(insertResult).insertId);
+        let loaded = await this.findOne(table, {
+            where,
+            with: options.with,
+        });
+        if (!loaded) {
+            throw new DataTableQueryError('create({ returnRow: true }) failed to load inserted row');
+        }
+        return loaded;
+    }
+    async createMany(table, values, options) {
+        let query = this.query(asQueryTableInput(table));
+        if (options?.returnRows === true) {
+            if (!this.#adapter.capabilities.returning) {
+                throw new DataTableQueryError('createMany({ returnRows: true }) is not supported by this adapter');
+            }
+            let result = (await query.insertMany(values, {
+                returning: '*',
+                touch: options.touch,
+            }));
+            return result.rows;
+        }
+        let result = await query.insertMany(values, {
+            touch: options?.touch,
+        });
+        return toWriteResult(result);
+    }
+    async find(table, value, options) {
+        if (value == null) {
+            return null;
+        }
+        let query = this.query(asQueryTableInput(table));
+        if (options?.with) {
+            return query.with(options.with).find(value);
+        }
+        return query.find(value);
+    }
+    async findOne(table, options) {
+        let query = this.query(asQueryTableInput(table)).where(options.where);
+        let orderBy = normalizeOrderByInput(options.orderBy);
+        for (let [column, direction] of orderBy) {
+            query = query.orderBy(column, direction);
+        }
+        if (options.with) {
+            return query.with(options.with).first();
+        }
+        return query.first();
+    }
+    async findMany(table, options) {
+        let query = this.query(asQueryTableInput(table));
+        if (options?.where) {
+            query = query.where(options.where);
+        }
+        let orderBy = normalizeOrderByInput(options?.orderBy);
+        for (let [column, direction] of orderBy) {
+            query = query.orderBy(column, direction);
+        }
+        if (options?.limit !== undefined) {
+            query = query.limit(options.limit);
+        }
+        if (options?.offset !== undefined) {
+            query = query.offset(options.offset);
+        }
+        if (options?.with) {
+            return query.with(options.with).all();
+        }
+        return query.all();
+    }
+    async count(table, options) {
+        let query = this.query(asQueryTableInput(table));
+        if (options?.where) {
+            query = query.where(options.where);
+        }
+        return query.count();
+    }
+    async update(table, value, changes, options) {
+        let where = getPrimaryKeyWhere(table, value);
+        if (this.#adapter.capabilities.returning) {
+            let updateResult = (await this.query(asQueryTableInput(table)).where(where).update(changes, {
+                touch: options?.touch,
+                returning: '*',
+            }));
+            let updatedRow = updateResult.rows[0];
+            if (!updatedRow) {
+                throw new DataTableQueryError('update() failed to find row for table "' + getTableName(table) + '"');
+            }
+            if (!options?.with) {
+                return updatedRow;
+            }
+            let loaded = await this.findOne(table, {
+                where: getPrimaryKeyWhereFromRow(table, updatedRow),
+                with: options.with,
+            });
+            if (!loaded) {
+                throw new DataTableQueryError('update() failed to find row for table "' + getTableName(table) + '"');
+            }
+            return loaded;
+        }
+        await this.query(asQueryTableInput(table)).where(where).update(changes, {
+            touch: options?.touch,
+        });
+        let loaded = await this.find(table, value, { with: options?.with });
+        if (!loaded) {
+            throw new DataTableQueryError('update() failed to find row for table "' + getTableName(table) + '"');
+        }
+        return loaded;
+    }
+    async updateMany(table, changes, options) {
+        let query = this.query(asQueryTableInput(table)).where(options.where);
+        let orderBy = normalizeOrderByInput(options.orderBy);
+        for (let [column, direction] of orderBy) {
+            query = query.orderBy(column, direction);
+        }
+        if (options.limit !== undefined) {
+            query = query.limit(options.limit);
+        }
+        if (options.offset !== undefined) {
+            query = query.offset(options.offset);
+        }
+        let result = await query.update(changes, { touch: options.touch });
+        return toWriteResult(result);
+    }
+    async delete(table, value) {
+        let where = getPrimaryKeyWhere(table, value);
+        let result = await this.query(asQueryTableInput(table)).where(where).delete();
+        return toWriteResult(result).affectedRows > 0;
+    }
+    async deleteMany(table, options) {
+        let query = this.query(asQueryTableInput(table)).where(options.where);
+        let orderBy = normalizeOrderByInput(options.orderBy);
+        for (let [column, direction] of orderBy) {
+            query = query.orderBy(column, direction);
+        }
+        if (options.limit !== undefined) {
+            query = query.limit(options.limit);
+        }
+        if (options.offset !== undefined) {
+            query = query.offset(options.offset);
+        }
+        let result = await query.delete();
+        return toWriteResult(result);
+    }
+    async exec(statementOrInput, values = []) {
+        if (typeof statementOrInput === 'string' || isSqlStatement(statementOrInput)) {
+            let sqlStatement = isSqlStatement(statementOrInput)
+                ? statementOrInput
+                : rawSql(statementOrInput, values);
+            return this[executeOperation]({
+                kind: 'raw',
+                sql: sqlStatement,
+            });
+        }
+        return executeQuery(this, statementOrInput);
+    }
+    async transaction(callback, options) {
+        if (!this.#token) {
+            let token = await this.#adapter.beginTransaction(options);
+            let tx = Database[createInternalDatabase](this.#adapter, { now: this.#now }, {
+                token,
+                savepointCounter: this.#savepointCounter,
+            });
+            try {
+                let result = await callback(tx);
+                await this.#adapter.commitTransaction(token);
+                return result;
+            }
+            catch (error) {
+                await this.#adapter.rollbackTransaction(token);
+                throw error;
+            }
+        }
+        if (!this.#adapter.capabilities.savepoints) {
+            throw new DataTableQueryError('Nested transactions require adapter savepoint support');
+        }
+        let savepointName = 'sp_' + String(this.#savepointCounter.value);
+        this.#savepointCounter.value += 1;
+        await this.#adapter.createSavepoint(this.#token, savepointName);
+        try {
+            let result = await callback(this);
+            await this.#adapter.releaseSavepoint(this.#token, savepointName);
+            return result;
+        }
+        catch (error) {
+            await this.#adapter.rollbackToSavepoint(this.#token, savepointName);
+            await this.#adapter.releaseSavepoint(this.#token, savepointName);
+            throw error;
+        }
+    }
+    async [executeOperation](operation) {
+        try {
+            return await this.#adapter.execute({
+                operation,
+                transaction: this.#token,
+            });
+        }
+        catch (error) {
+            throw new DataTableAdapterError('Adapter execution failed', {
+                cause: error,
+                metadata: {
+                    dialect: this.#adapter.dialect,
+                    operationKind: operation.kind,
+                },
+            });
+        }
+    }
+}
+/**
+ * Creates a database runtime from an adapter.
+ * Thin wrapper around `new Database(adapter, options)`.
+ * @param adapter Adapter implementation responsible for SQL execution.
+ * @param options Optional runtime options.
+ * @param options.now Clock function used for auto-managed timestamps.
+ * @returns A {@link Database} API instance.
+ * @example
+ * ```ts
+ * import { column as c, createDatabase, table } from 'remix/data-table'
+ *
+ * let users = table({
+ *   name: 'users',
+ *   columns: {
+ *     id: c.integer(),
+ *     email: c.varchar(255),
+ *   },
+ * })
+ *
+ * let db = createDatabase(adapter)
+ * let rows = await db.query(users).where({ id: 1 }).all()
+ * ```
+ */
+export function createDatabase(adapter, options) {
+    return new Database(adapter, options);
+}
+/**
+ * Creates a database runtime bound to an existing adapter transaction token.
+ * This is an internal helper used by the migration runner.
+ * @param adapter Adapter implementation responsible for SQL execution.
+ * @param token Active adapter transaction token.
+ * @param options Optional runtime options.
+ * @param options.now Clock function used for auto-managed timestamps.
+ * @returns A {@link Database} API instance bound to the provided transaction.
+ */
+export function createDatabaseWithTransaction(adapter, token, options) {
+    return Database[createInternalDatabase](adapter, options, {
+        token,
+        savepointCounter: { value: 0 },
+    });
+}
+function defaultNow() {
+    return new Date();
+}

package/dist/lib/errors.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Base error for all `data-table` failures.
+ */
+export declare class DataTableError extends Error {
+    /**
+     * Stable error code identifying the failure category.
+     */
+    code: string;
+    /**
+     * Optional structured metadata attached to the failure.
+     */
+    metadata?: Record<string, unknown>;
+    constructor(message: string, options?: {
+        code?: string;
+        cause?: unknown;
+        metadata?: Record<string, unknown>;
+    });
+}
+/**
+ * Thrown when input data fails schema validation.
+ */
+export declare class DataTableValidationError extends DataTableError {
+    /**
+     * Validation issues reported by the schema validator.
+     */
+    issues: ReadonlyArray<unknown>;
+    constructor(message: string, issues: ReadonlyArray<unknown>, options?: {
+        cause?: unknown;
+        metadata?: Record<string, unknown>;
+    });
+}
+/**
+ * Thrown when a query is invalid for the current builder state.
+ */
+export declare class DataTableQueryError extends DataTableError {
+    constructor(message: string, options?: {
+        cause?: unknown;
+        metadata?: Record<string, unknown>;
+    });
+}
+/**
+ * Thrown when adapter execution fails.
+ */
+export declare class DataTableAdapterError extends DataTableError {
+    constructor(message: string, options?: {
+        cause?: unknown;
+        metadata?: Record<string, unknown>;
+    });
+}
+/**
+ * Thrown when a database constraint is violated.
+ */
+export declare class DataTableConstraintError extends DataTableError {
+    constructor(message: string, options?: {
+        cause?: unknown;
+        metadata?: Record<string, unknown>;
+    });
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/lib/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/lib/errors.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,cAAe,SAAQ,KAAK;IACvC;;OAEG;IACH,IAAI,EAAE,MAAM,CAAA;IAEZ;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAElC,YACE,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE;QACR,IAAI,CAAC,EAAE,MAAM,CAAA;QACb,KAAK,CAAC,EAAE,OAAO,CAAA;QACf,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KACnC,EAMF;CACF;AAED;;GAEG;AACH,qBAAa,wBAAyB,SAAQ,cAAc;IAC1D;;OAEG;IACH,MAAM,EAAE,aAAa,CAAC,OAAO,CAAC,CAAA;IAE9B,YACE,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,aAAa,CAAC,OAAO,CAAC,EAC9B,OAAO,CAAC,EAAE;QACR,KAAK,CAAC,EAAE,OAAO,CAAA;QACf,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KACnC,EAUF;CACF;AAED;;GAEG;AACH,qBAAa,mBAAoB,SAAQ,cAAc;IACrD,YACE,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE;QACR,KAAK,CAAC,EAAE,OAAO,CAAA;QACf,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KACnC,EASF;CACF;AAED;;GAEG;AACH,qBAAa,qBAAsB,SAAQ,cAAc;IACvD,YACE,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE;QACR,KAAK,CAAC,EAAE,OAAO,CAAA;QACf,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KACnC,EASF;CACF;AAED;;GAEG;AACH,qBAAa,wBAAyB,SAAQ,cAAc;IAC1D,YACE,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE;QACR,KAAK,CAAC,EAAE,OAAO,CAAA;QACf,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KACnC,EASF;CACF"}

package/dist/lib/errors.js

@@ -0,0 +1,76 @@
+/**
+ * Base error for all `data-table` failures.
+ */
+export class DataTableError extends Error {
+    /**
+     * Stable error code identifying the failure category.
+     */
+    code;
+    /**
+     * Optional structured metadata attached to the failure.
+     */
+    metadata;
+    constructor(message, options) {
+        super(message, { cause: options?.cause });
+        this.name = 'DataTableError';
+        this.code = options?.code ?? 'DATA_TABLE_ERROR';
+        this.metadata = options?.metadata;
+    }
+}
+/**
+ * Thrown when input data fails schema validation.
+ */
+export class DataTableValidationError extends DataTableError {
+    /**
+     * Validation issues reported by the schema validator.
+     */
+    issues;
+    constructor(message, issues, options) {
+        super(message, {
+            code: 'DATA_TABLE_VALIDATION_ERROR',
+            cause: options?.cause,
+            metadata: options?.metadata,
+        });
+        this.name = 'DataTableValidationError';
+        this.issues = issues;
+    }
+}
+/**
+ * Thrown when a query is invalid for the current builder state.
+ */
+export class DataTableQueryError extends DataTableError {
+    constructor(message, options) {
+        super(message, {
+            code: 'DATA_TABLE_QUERY_ERROR',
+            cause: options?.cause,
+            metadata: options?.metadata,
+        });
+        this.name = 'DataTableQueryError';
+    }
+}
+/**
+ * Thrown when adapter execution fails.
+ */
+export class DataTableAdapterError extends DataTableError {
+    constructor(message, options) {
+        super(message, {
+            code: 'DATA_TABLE_ADAPTER_ERROR',
+            cause: options?.cause,
+            metadata: options?.metadata,
+        });
+        this.name = 'DataTableAdapterError';
+    }
+}
+/**
+ * Thrown when a database constraint is violated.
+ */
+export class DataTableConstraintError extends DataTableError {
+    constructor(message, options) {
+        super(message, {
+            code: 'DATA_TABLE_CONSTRAINT_ERROR',
+            cause: options?.cause,
+            metadata: options?.metadata,
+        });
+        this.name = 'DataTableConstraintError';
+    }
+}

package/dist/lib/inflection.d.ts

@@ -0,0 +1,3 @@
+export declare function singularize(word: string): string;
+export declare function inferForeignKey(tableName: string): string;
+//# sourceMappingURL=inflection.d.ts.map

package/dist/lib/inflection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inflection.d.ts","sourceRoot":"","sources":["../../src/lib/inflection.ts"],"names":[],"mappings":"AAoBA,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAwBhD;AAED,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAUzD"}

package/dist/lib/inflection.js

@@ -0,0 +1,56 @@
+const IRREGULAR_SINGULAR_FORMS = {
+    people: 'person',
+    men: 'man',
+    women: 'woman',
+    children: 'child',
+    teeth: 'tooth',
+    feet: 'foot',
+    geese: 'goose',
+    mice: 'mouse',
+    data: 'datum',
+    media: 'medium',
+    indices: 'index',
+    vertices: 'vertex',
+    analyses: 'analysis',
+    statuses: 'status',
+    categories: 'category',
+    companies: 'company',
+    addresses: 'address',
+};
+export function singularize(word) {
+    let lower = word.toLowerCase();
+    if (IRREGULAR_SINGULAR_FORMS[lower]) {
+        return preserveCase(word, IRREGULAR_SINGULAR_FORMS[lower]);
+    }
+    if (lower.endsWith('ies') && lower.length > 3) {
+        return preserveCase(word, word.slice(0, -3) + 'y');
+    }
+    if (lower.endsWith('sses') || lower.endsWith('shes') || lower.endsWith('ches')) {
+        return preserveCase(word, word.slice(0, -2));
+    }
+    if (lower.endsWith('xes') || lower.endsWith('zes')) {
+        return preserveCase(word, word.slice(0, -2));
+    }
+    if (lower.endsWith('s') && !lower.endsWith('ss')) {
+        return preserveCase(word, word.slice(0, -1));
+    }
+    return word;
+}
+export function inferForeignKey(tableName) {
+    let segments = tableName.split('_');
+    let tail = segments.pop() ?? tableName;
+    let singularTail = singularize(tail);
+    if (segments.length === 0) {
+        return singularTail + '_id';
+    }
+    return [...segments, singularTail + '_id'].join('_');
+}
+function preserveCase(source, replacement) {
+    if (source.length === 0) {
+        return replacement;
+    }
+    if (source[0] === source[0].toUpperCase()) {
+        return replacement[0].toUpperCase() + replacement.slice(1);
+    }
+    return replacement;
+}

package/dist/lib/migrations/filename.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Parses a migration filename into `{ id, name }`.
+ *
+ * Expected format: `YYYYMMDDHHmmss_name.(ts|js|mts|mjs|cts|cjs)`.
+ * @param filename Migration file basename.
+ * @returns Parsed migration id and name.
+ */
+export declare function parseMigrationFilename(filename: string): {
+    id: string;
+    name: string;
+};
+//# sourceMappingURL=filename.d.ts.map

package/dist/lib/migrations/filename.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filename.d.ts","sourceRoot":"","sources":["../../../src/lib/migrations/filename.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAerF"}

package/dist/lib/migrations/filename.js

@@ -0,0 +1,20 @@
+const migrationFilenamePattern = /^(\d{14})_(.+)\.(?:m?ts|m?js|cts|cjs)$/;
+/**
+ * Parses a migration filename into `{ id, name }`.
+ *
+ * Expected format: `YYYYMMDDHHmmss_name.(ts|js|mts|mjs|cts|cjs)`.
+ * @param filename Migration file basename.
+ * @returns Parsed migration id and name.
+ */
+export function parseMigrationFilename(filename) {
+    let match = filename.match(migrationFilenamePattern);
+    if (!match) {
+        throw new Error('Invalid migration filename "' +
+            filename +
+            '". Expected format YYYYMMDDHHmmss_name.ts (or .js/.mts/.mjs/.cts/.cjs)');
+    }
+    return {
+        id: match[1],
+        name: match[2],
+    };
+}

package/dist/lib/migrations/helpers.d.ts

@@ -0,0 +1,11 @@
+import type { TableRef } from '../adapter.ts';
+import type { IndexColumns, KeyColumns } from '../migrations.ts';
+export declare function toTableRef(name: string): TableRef;
+export declare function normalizeIndexColumns(columns: IndexColumns): string[];
+export declare function normalizeKeyColumns(columns: KeyColumns): string[];
+export declare function createPrimaryKeyName(table: TableRef): string;
+export declare function createUniqueName(table: TableRef, columns: string[]): string;
+export declare function createForeignKeyName(table: TableRef, columns: string[], references: TableRef, referenceColumns: string[]): string;
+export declare function createCheckName(table: TableRef, expression: string): string;
+export declare function createIndexName(table: TableRef, columns: string[]): string;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/lib/migrations/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/lib/migrations/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAC7C,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAEhE,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,CAWjD;AAED,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,YAAY,GAAG,MAAM,EAAE,CAErE;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,UAAU,GAAG,MAAM,EAAE,CAMjE;AAgDD,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,QAAQ,GAAG,MAAM,CAE5D;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,MAAM,CAE3E;AAED,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,QAAQ,EACf,OAAO,EAAE,MAAM,EAAE,EACjB,UAAU,EAAE,QAAQ,EACpB,gBAAgB,EAAE,MAAM,EAAE,GACzB,MAAM,CAWR;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAG3E;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,MAAM,CAE1E"}

package/dist/lib/migrations/helpers.js

@@ -0,0 +1,77 @@
+export function toTableRef(name) {
+    let segments = name.split('.');
+    if (segments.length === 1) {
+        return { name };
+    }
+    return {
+        schema: segments[0],
+        name: segments.slice(1).join('.'),
+    };
+}
+export function normalizeIndexColumns(columns) {
+    return normalizeKeyColumns(columns);
+}
+export function normalizeKeyColumns(columns) {
+    if (Array.isArray(columns)) {
+        return [...columns];
+    }
+    return [columns];
+}
+function normalizeNamePart(value) {
+    let normalized = value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '_')
+        .replace(/^_+|_+$/g, '');
+    if (normalized.length === 0) {
+        return 'item';
+    }
+    return normalized;
+}
+function tableNamePart(table) {
+    if (table.schema) {
+        return normalizeNamePart(table.schema + '_' + table.name);
+    }
+    return normalizeNamePart(table.name);
+}
+function hashString(value) {
+    let hash = 5381;
+    for (let index = 0; index < value.length; index++) {
+        hash = ((hash << 5) + hash) ^ value.charCodeAt(index);
+    }
+    return hash >>> 0;
+}
+function withNameLimit(name) {
+    let limit = 63;
+    if (name.length <= limit) {
+        return name;
+    }
+    let suffix = hashString(name).toString(36).padStart(8, '0').slice(0, 8);
+    return name.slice(0, limit - 9) + '_' + suffix;
+}
+function columnsNamePart(columns) {
+    return columns.map((column) => normalizeNamePart(column)).join('_');
+}
+export function createPrimaryKeyName(table) {
+    return withNameLimit(tableNamePart(table) + '_pk');
+}
+export function createUniqueName(table, columns) {
+    return withNameLimit(tableNamePart(table) + '_' + columnsNamePart(columns) + '_uq');
+}
+export function createForeignKeyName(table, columns, references, referenceColumns) {
+    let base = tableNamePart(table) +
+        '_' +
+        columnsNamePart(columns) +
+        '_' +
+        tableNamePart(references) +
+        '_' +
+        columnsNamePart(referenceColumns) +
+        '_fk';
+    return withNameLimit(base);
+}
+export function createCheckName(table, expression) {
+    let suffix = hashString(expression).toString(36);
+    return withNameLimit(tableNamePart(table) + '_chk_' + suffix);
+}
+export function createIndexName(table, columns) {
+    return withNameLimit(tableNamePart(table) + '_' + columnsNamePart(columns) + '_idx');
+}

package/dist/lib/migrations/journal-store.d.ts

@@ -0,0 +1,15 @@
+import type { DatabaseAdapter, TransactionToken } from '../adapter.ts';
+import type { MigrationDescriptor, MigrationJournalRow } from '../migrations.ts';
+export declare function normalizeChecksum(migration: MigrationDescriptor): string;
+export declare function ensureMigrationJournal(adapter: DatabaseAdapter, tableName: string): Promise<void>;
+export declare function hasMigrationJournal(adapter: DatabaseAdapter, tableName: string): Promise<boolean>;
+export declare function loadJournalRows(adapter: DatabaseAdapter, tableName: string): Promise<MigrationJournalRow[]>;
+export declare function insertJournalRow(adapter: DatabaseAdapter, tableName: string, row: {
+    id: string;
+    name: string;
+    checksum: string;
+    batch: number;
+}, transaction?: TransactionToken): Promise<void>;
+export declare function deleteJournalRow(adapter: DatabaseAdapter, tableName: string, id: string, transaction?: TransactionToken): Promise<void>;
+export declare function getBatch(rows: MigrationJournalRow[]): number;
+//# sourceMappingURL=journal-store.d.ts.map

package/dist/lib/migrations/journal-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"journal-store.d.ts","sourceRoot":"","sources":["../../../src/lib/migrations/journal-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAA;AAEtE,OAAO,KAAK,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAA;AAEhF,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,mBAAmB,GAAG,MAAM,CAMxE;AAED,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,eAAe,EACxB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,IAAI,CAAC,CAef;AAED,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,eAAe,EACxB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,OAAO,CAAC,CAalB;AAED,wBAAsB,eAAe,CACnC,OAAO,EAAE,eAAe,EACxB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAmBhC;AAED,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,eAAe,EACxB,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE;IACH,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,EAAE,MAAM,CAAA;CACd,EACD,WAAW,CAAC,EAAE,gBAAgB,GAC7B,OAAO,CAAC,IAAI,CAAC,CAaf;AAED,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,eAAe,EACxB,SAAS,EAAE,MAAM,EACjB,EAAE,EAAE,MAAM,EACV,WAAW,CAAC,EAAE,gBAAgB,GAC7B,OAAO,CAAC,IAAI,CAAC,CAQf;AAED,wBAAgB,QAAQ,CAAC,IAAI,EAAE,mBAAmB,EAAE,GAAG,MAAM,CAO5D"}