@remix-run/data-table 0.1.0 → 0.2.1

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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,326 @@
+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);
+        },
+    };
+}

package/dist/lib/migrations-node.d.ts

@@ -0,0 +1,17 @@
+import type { MigrationDescriptor } from './migrations.ts';
+/**
+ * Loads migration modules from a directory on Node.js.
+ *
+ * Filenames are used to infer migration `id` and `name`.
+ * Each file must default-export `createMigration(...)`.
+ * @param directory Absolute or relative directory containing migration files.
+ * @returns A sorted list of loaded migration descriptors.
+ * @example
+ * ```ts
+ * import { loadMigrations } from 'remix/data-table/migrations/node'
+ *
+ * let migrations = await loadMigrations('./app/db/migrations')
+ * ```
+ */
+export declare function loadMigrations(directory: string): Promise<MigrationDescriptor[]>;
+//# sourceMappingURL=migrations-node.d.ts.map

package/dist/lib/migrations-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrations-node.d.ts","sourceRoot":"","sources":["../../src/lib/migrations-node.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAa,mBAAmB,EAAE,MAAM,iBAAiB,CAAA;AAGrE;;;;;;;;;;;;;GAaG;AACH,wBAAsB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAiDtF"}

package/dist/lib/migrations-node.js

@@ -0,0 +1,65 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { createHash } from 'node:crypto';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { parseMigrationFilename } from "./migrations/filename.js";
+/**
+ * Loads migration modules from a directory on Node.js.
+ *
+ * Filenames are used to infer migration `id` and `name`.
+ * Each file must default-export `createMigration(...)`.
+ * @param directory Absolute or relative directory containing migration files.
+ * @returns A sorted list of loaded migration descriptors.
+ * @example
+ * ```ts
+ * import { loadMigrations } from 'remix/data-table/migrations/node'
+ *
+ * let migrations = await loadMigrations('./app/db/migrations')
+ * ```
+ */
+export async function loadMigrations(directory) {
+    let allFiles = (await fs.readdir(directory, { withFileTypes: true }))
+        .filter((entry) => entry.isFile())
+        .map((entry) => entry.name)
+        .sort((left, right) => left.localeCompare(right));
+    let files = [];
+    for (let file of allFiles) {
+        if (!/\.(?:m?ts|m?js|cts|cjs)$/.test(file)) {
+            continue;
+        }
+        let parsed = parseMigrationFilename(file);
+        files.push({ file, id: parsed.id, name: parsed.name });
+    }
+    let migrations = [];
+    let seenIds = new Set();
+    for (let entry of files) {
+        if (seenIds.has(entry.id)) {
+            throw new Error('Duplicate migration id "' + entry.id + '" inferred from filename "' + entry.file + '"');
+        }
+        seenIds.add(entry.id);
+        let fullPath = path.join(directory, entry.file);
+        let source = await fs.readFile(fullPath, 'utf8');
+        let checksum = createHash('sha256').update(source).digest('hex');
+        let module = (await import(__rewriteRelativeImportExtension(pathToFileURL(fullPath).href)));
+        let migration = module.default;
+        if (!migration || typeof migration.up !== 'function' || typeof migration.down !== 'function') {
+            throw new Error('Migration file "' + entry.file + '" must default-export createMigration(...)');
+        }
+        migrations.push({
+            id: entry.id,
+            name: entry.name,
+            path: fullPath,
+            checksum,
+            migration,
+        });
+    }
+    return migrations;
+}