@remix-run/data-table 0.2.1 → 0.4.0

package/dist/lib/migrations/helpers.js

@@ -1,77 +0,0 @@
-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/schema-api.d.ts

@@ -1,7 +0,0 @@
-import type { Database } from '../database.ts';
-import type { DataMigrationOperation, TransactionToken } from '../adapter.ts';
-import type { MigrationSchema } from '../migrations.ts';
-export declare function createMigrationSchema(db: Database, emit: (operation: DataMigrationOperation) => Promise<void>, options?: {
-    transaction?: TransactionToken;
-}): MigrationSchema;
-//# sourceMappingURL=schema-api.d.ts.map

package/dist/lib/migrations/schema-api.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema-api.d.ts","sourceRoot":"","sources":["../../../src/lib/migrations/schema-api.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAC9C,OAAO,KAAK,EAKV,sBAAsB,EAItB,gBAAgB,EAEjB,MAAM,eAAe,CAAA;AAItB,OAAO,KAAK,EAKV,eAAe,EAGhB,MAAM,kBAAkB,CAAA;AA+PzB,wBAAgB,qBAAqB,CACnC,EAAE,EAAE,QAAQ,EACZ,IAAI,EAAE,CAAC,SAAS,EAAE,sBAAsB,KAAK,OAAO,CAAC,IAAI,CAAC,EAC1D,OAAO,CAAC,EAAE;IAAE,WAAW,CAAC,EAAE,gBAAgB,CAAA;CAAE,GAC3C,eAAe,CAqIjB"}

package/dist/lib/migrations/schema-api.js

@@ -1,326 +0,0 @@
-import { rawSql } from "../sql.js";
-import { getTableColumnDefinitions, getTableName, getTablePrimaryKey } from "../table.js";
-import { ColumnBuilder } from "../column.js";
-import { createCheckName, createForeignKeyName, createIndexName, createPrimaryKeyName, createUniqueName, normalizeIndexColumns, normalizeKeyColumns, toTableRef, } from "./helpers.js";
-function asColumnDefinition(definition) {
-    if (definition instanceof ColumnBuilder) {
-        return definition.build();
-    }
-    return definition;
-}
-function asTableRef(value) {
-    if (typeof value === 'string') {
-        return toTableRef(value);
-    }
-    return toTableRef(getTableName(value));
-}
-function lowerTableForCreate(table) {
-    let tableRef = toTableRef(getTableName(table));
-    let sourceColumnDefinitions = getTableColumnDefinitions(table);
-    let columns = {};
-    let uniques = [];
-    let checks = [];
-    let foreignKeys = [];
-    for (let columnName in sourceColumnDefinitions) {
-        if (!Object.prototype.hasOwnProperty.call(sourceColumnDefinitions, columnName)) {
-            continue;
-        }
-        let sourceDefinition = sourceColumnDefinitions[columnName];
-        let columnDefinition = {
-            ...sourceDefinition,
-            checks: undefined,
-            references: undefined,
-            primaryKey: undefined,
-        };
-        let unique = sourceDefinition.unique;
-        if (unique) {
-            let uniqueName = typeof unique === 'object' && unique.name
-                ? unique.name
-                : createUniqueName(tableRef, [columnName]);
-            uniques.push({
-                name: uniqueName,
-                columns: [columnName],
-            });
-            columnDefinition.unique = undefined;
-        }
-        if (sourceDefinition.checks) {
-            for (let check of sourceDefinition.checks) {
-                checks.push({
-                    name: check.name || createCheckName(tableRef, check.expression),
-                    expression: check.expression,
-                });
-            }
-        }
-        if (sourceDefinition.references) {
-            let referenceColumns = [...sourceDefinition.references.columns];
-            let referencesTable = { ...sourceDefinition.references.table };
-            foreignKeys.push({
-                name: sourceDefinition.references.name ||
-                    createForeignKeyName(tableRef, [columnName], referencesTable, referenceColumns),
-                columns: [columnName],
-                references: {
-                    table: referencesTable,
-                    columns: referenceColumns,
-                },
-                onDelete: sourceDefinition.references.onDelete,
-                onUpdate: sourceDefinition.references.onUpdate,
-            });
-        }
-        columns[columnName] = columnDefinition;
-    }
-    let primaryKeyColumns = [...getTablePrimaryKey(table)];
-    let primaryKey;
-    if (primaryKeyColumns.length > 0) {
-        primaryKey = {
-            columns: primaryKeyColumns,
-            name: createPrimaryKeyName(tableRef),
-        };
-    }
-    return {
-        kind: 'createTable',
-        table: tableRef,
-        columns,
-        primaryKey,
-        uniques: uniques.length > 0 ? uniques : undefined,
-        checks: checks.length > 0 ? checks : undefined,
-        foreignKeys: foreignKeys.length > 0 ? foreignKeys : undefined,
-    };
-}
-class AlterTableBuilderRuntime {
-    alterChanges = [];
-    extraStatements = [];
-    table;
-    constructor(table) {
-        this.table = table;
-    }
-    addColumn(name, definition) {
-        this.alterChanges.push({
-            kind: 'addColumn',
-            column: name,
-            definition: asColumnDefinition(definition),
-        });
-    }
-    changeColumn(name, definition) {
-        this.alterChanges.push({
-            kind: 'changeColumn',
-            column: name,
-            definition: asColumnDefinition(definition),
-        });
-    }
-    renameColumn(from, to) {
-        this.alterChanges.push({ kind: 'renameColumn', from, to });
-    }
-    dropColumn(name, options) {
-        this.alterChanges.push({ kind: 'dropColumn', column: name, ifExists: options?.ifExists });
-    }
-    addPrimaryKey(columns, options) {
-        let normalizedColumns = normalizeKeyColumns(columns);
-        this.alterChanges.push({
-            kind: 'addPrimaryKey',
-            constraint: {
-                columns: normalizedColumns,
-                name: options?.name ?? createPrimaryKeyName(this.table),
-            },
-        });
-    }
-    dropPrimaryKey(name) {
-        this.alterChanges.push({ kind: 'dropPrimaryKey', name });
-    }
-    addUnique(columns, options) {
-        let normalizedColumns = normalizeKeyColumns(columns);
-        this.alterChanges.push({
-            kind: 'addUnique',
-            constraint: {
-                columns: normalizedColumns,
-                name: options?.name ?? createUniqueName(this.table, normalizedColumns),
-            },
-        });
-    }
-    dropUnique(name) {
-        this.alterChanges.push({ kind: 'dropUnique', name });
-    }
-    addForeignKey(columns, refTable, refColumns, options) {
-        let normalizedColumns = normalizeKeyColumns(columns);
-        let normalizedReferenceColumns = refColumns ? normalizeKeyColumns(refColumns) : ['id'];
-        let referenceTable = asTableRef(refTable);
-        this.alterChanges.push({
-            kind: 'addForeignKey',
-            constraint: {
-                columns: normalizedColumns,
-                references: {
-                    table: referenceTable,
-                    columns: normalizedReferenceColumns,
-                },
-                name: options?.name ??
-                    createForeignKeyName(this.table, normalizedColumns, referenceTable, normalizedReferenceColumns),
-                onDelete: options?.onDelete,
-                onUpdate: options?.onUpdate,
-            },
-        });
-    }
-    dropForeignKey(name) {
-        this.alterChanges.push({ kind: 'dropForeignKey', name });
-    }
-    addCheck(expression, options) {
-        this.alterChanges.push({
-            kind: 'addCheck',
-            constraint: {
-                expression,
-                name: options?.name ?? createCheckName(this.table, expression),
-            },
-        });
-    }
-    dropCheck(name) {
-        this.alterChanges.push({ kind: 'dropCheck', name });
-    }
-    addIndex(columns, options) {
-        let normalizedColumns = normalizeIndexColumns(columns);
-        let { name, ifNotExists, ...indexOptions } = options ?? {};
-        this.extraStatements.push({
-            kind: 'createIndex',
-            index: {
-                table: this.table,
-                name: name ?? createIndexName(this.table, normalizedColumns),
-                columns: normalizedColumns,
-                ...indexOptions,
-            },
-            ifNotExists,
-        });
-    }
-    dropIndex(name) {
-        this.extraStatements.push({
-            kind: 'dropIndex',
-            table: this.table,
-            name,
-        });
-    }
-    comment(text) {
-        this.alterChanges.push({ kind: 'setTableComment', comment: text });
-    }
-}
-export function createMigrationSchema(db, emit, options) {
-    return {
-        async createTable(table, options) {
-            let operation = lowerTableForCreate(table);
-            operation.ifNotExists = options?.ifNotExists;
-            await emit(operation);
-        },
-        async alterTable(input, migrate, options) {
-            let tableRef = asTableRef(input);
-            let builder = new AlterTableBuilderRuntime(tableRef);
-            migrate(builder);
-            if (builder.alterChanges.length > 0) {
-                await emit({
-                    kind: 'alterTable',
-                    table: tableRef,
-                    changes: builder.alterChanges,
-                    ifExists: options?.ifExists,
-                });
-            }
-            for (let operation of builder.extraStatements) {
-                await emit(operation);
-            }
-        },
-        async renameTable(from, to) {
-            await emit({ kind: 'renameTable', from: asTableRef(from), to: toTableRef(to) });
-        },
-        async dropTable(table, options) {
-            await emit({
-                kind: 'dropTable',
-                table: asTableRef(table),
-                ifExists: options?.ifExists,
-                cascade: options?.cascade,
-            });
-        },
-        async createIndex(table, columns, options) {
-            let tableRef = asTableRef(table);
-            let normalizedColumns = normalizeIndexColumns(columns);
-            let { name, ifNotExists, ...indexOptions } = options ?? {};
-            await emit({
-                kind: 'createIndex',
-                index: {
-                    table: tableRef,
-                    name: name ?? createIndexName(tableRef, normalizedColumns),
-                    columns: normalizedColumns,
-                    ...indexOptions,
-                },
-                ifNotExists,
-            });
-        },
-        async dropIndex(table, name, options) {
-            await emit({
-                kind: 'dropIndex',
-                table: asTableRef(table),
-                name,
-                ifExists: options?.ifExists,
-            });
-        },
-        async renameIndex(table, from, to) {
-            await emit({
-                kind: 'renameIndex',
-                table: asTableRef(table),
-                from,
-                to,
-            });
-        },
-        async addForeignKey(table, columns, refTable, refColumns, options) {
-            let tableRef = asTableRef(table);
-            let normalizedColumns = normalizeKeyColumns(columns);
-            let referenceTable = asTableRef(refTable);
-            let normalizedReferenceColumns = refColumns ? normalizeKeyColumns(refColumns) : ['id'];
-            await emit({
-                kind: 'addForeignKey',
-                table: tableRef,
-                constraint: {
-                    columns: normalizedColumns,
-                    references: {
-                        table: referenceTable,
-                        columns: normalizedReferenceColumns,
-                    },
-                    name: options?.name ??
-                        createForeignKeyName(tableRef, normalizedColumns, referenceTable, normalizedReferenceColumns),
-                    onDelete: options?.onDelete,
-                    onUpdate: options?.onUpdate,
-                },
-            });
-        },
-        async dropForeignKey(table, name) {
-            await emit({
-                kind: 'dropForeignKey',
-                table: asTableRef(table),
-                name,
-            });
-        },
-        async addCheck(table, expression, options) {
-            let tableRef = asTableRef(table);
-            await emit({
-                kind: 'addCheck',
-                table: tableRef,
-                constraint: {
-                    expression,
-                    name: options?.name ?? createCheckName(tableRef, expression),
-                },
-            });
-        },
-        async dropCheck(table, name) {
-            await emit({
-                kind: 'dropCheck',
-                table: asTableRef(table),
-                name,
-            });
-        },
-        async plan(sql) {
-            let statement = typeof sql === 'string' ? rawSql(sql) : sql;
-            await emit({
-                kind: 'raw',
-                sql: statement,
-            });
-        },
-        async hasTable(table) {
-            return db.adapter.hasTable(asTableRef(table), options?.transaction);
-        },
-        async hasColumn(table, columnName) {
-            return db.adapter.hasColumn(asTableRef(table), columnName, options?.transaction);
-        },
-    };
-}