@remix-run/data-table 0.0.0 → 0.2.0

package/dist/lib/table.js

@@ -0,0 +1,519 @@
+import { ColumnBuilder } from "./column.js";
+import { inferForeignKey } from "./inflection.js";
+import { normalizeWhereInput } from "./operators.js";
+import { columnMetadataKey, normalizeColumnInput, tableMetadataKey } from "./references.js";
+/**
+ * Symbol key used to store non-enumerable table metadata.
+ */
+export { columnMetadataKey, tableMetadataKey } from "./references.js";
+/**
+ * Creates a plain table reference snapshot from a table instance.
+ * @param table Source table instance.
+ * @returns Table metadata snapshot.
+ */
+export function getTableReference(table) {
+    let metadata = table[tableMetadataKey];
+    return {
+        kind: 'table',
+        name: metadata.name,
+        columns: metadata.columns,
+        primaryKey: metadata.primaryKey,
+        timestamps: metadata.timestamps,
+    };
+}
+/**
+ * Returns a table's SQL name.
+ * @param table Source table instance.
+ * @returns Table SQL name.
+ */
+export function getTableName(table) {
+    return table[tableMetadataKey].name;
+}
+/**
+ * Returns a table's column builder map.
+ * @param table Source table instance.
+ * @returns Table column builder map.
+ */
+export function getTableColumns(table) {
+    return table[tableMetadataKey].columns;
+}
+/**
+ * Returns a table's resolved physical column definitions.
+ * @param table Source table instance.
+ * @returns Column definition map.
+ */
+export function getTableColumnDefinitions(table) {
+    return table[tableMetadataKey].columnDefinitions;
+}
+/**
+ * Returns a table's optional write validator.
+ * @param table Source table instance.
+ * @returns Validation function or `undefined`.
+ */
+export function getTableValidator(table) {
+    return table[tableMetadataKey].validate;
+}
+/**
+ * Returns a table's optional before-write lifecycle callback.
+ * @param table Source table instance.
+ * @returns Before-write callback or `undefined`.
+ */
+export function getTableBeforeWrite(table) {
+    return table[tableMetadataKey].beforeWrite;
+}
+/**
+ * Returns a table's optional after-write lifecycle callback.
+ * @param table Source table instance.
+ * @returns After-write callback or `undefined`.
+ */
+export function getTableAfterWrite(table) {
+    return table[tableMetadataKey].afterWrite;
+}
+/**
+ * Returns a table's optional before-delete lifecycle callback.
+ * @param table Source table instance.
+ * @returns Before-delete callback or `undefined`.
+ */
+export function getTableBeforeDelete(table) {
+    return table[tableMetadataKey].beforeDelete;
+}
+/**
+ * Returns a table's optional after-delete lifecycle callback.
+ * @param table Source table instance.
+ * @returns After-delete callback or `undefined`.
+ */
+export function getTableAfterDelete(table) {
+    return table[tableMetadataKey].afterDelete;
+}
+/**
+ * Returns a table's optional after-read lifecycle callback.
+ * The callback receives the current read shape, which may be a projected partial row.
+ * @param table Source table instance.
+ * @returns After-read callback or `undefined`.
+ */
+export function getTableAfterRead(table) {
+    return table[tableMetadataKey].afterRead;
+}
+/**
+ * Returns a table's primary key columns.
+ * @param table Source table instance.
+ * @returns Primary key columns.
+ */
+export function getTablePrimaryKey(table) {
+    return table[tableMetadataKey].primaryKey;
+}
+/**
+ * Returns a table's resolved timestamp configuration.
+ * @param table Source table instance.
+ * @returns Timestamp configuration or `null`.
+ */
+export function getTableTimestamps(table) {
+    return table[tableMetadataKey].timestamps;
+}
+const defaultTimestampConfig = {
+    createdAt: 'created_at',
+    updatedAt: 'updated_at',
+};
+export function fail(messageOrIssues, path) {
+    if (typeof messageOrIssues === 'string') {
+        return {
+            issues: [{ message: messageOrIssues, path }],
+        };
+    }
+    return {
+        issues: [...messageOrIssues],
+    };
+}
+/**
+ * Creates a table object with symbol-backed metadata and direct column references.
+ * @param options Table declaration options.
+ * @returns A frozen table object.
+ * @example
+ * ```ts
+ * import { column as c, table } from 'remix/data-table'
+ *
+ * let users = table({
+ *   name: 'users',
+ *   columns: {
+ *     id: c.integer(),
+ *     email: c.varchar(255),
+ *   },
+ *   primaryKey: 'id',
+ * })
+ * ```
+ */
+export function table(options) {
+    let tableName = options.name;
+    let columns = options.columns;
+    let resolvedPrimaryKey = normalizePrimaryKey(tableName, columns, options.primaryKey);
+    let timestampConfig = normalizeTimestampConfig(options.timestamps);
+    let columnDefinitions = resolveTableColumns(tableName, columns);
+    let table = Object.create(null);
+    Object.defineProperty(table, tableMetadataKey, {
+        value: Object.freeze({
+            name: tableName,
+            columns,
+            primaryKey: resolvedPrimaryKey,
+            timestamps: timestampConfig,
+            columnDefinitions,
+            beforeWrite: options.beforeWrite,
+            afterWrite: options.afterWrite,
+            beforeDelete: options.beforeDelete,
+            afterDelete: options.afterDelete,
+            afterRead: options.afterRead,
+            validate: options.validate,
+        }),
+        enumerable: false,
+        writable: false,
+        configurable: false,
+    });
+    for (let columnName in columns) {
+        if (!Object.prototype.hasOwnProperty.call(columns, columnName)) {
+            continue;
+        }
+        let column = createColumnReference(tableName, columnName);
+        Object.defineProperty(table, columnName, {
+            value: column,
+            enumerable: true,
+            writable: false,
+            configurable: false,
+        });
+    }
+    return Object.freeze(table);
+}
+function createColumnReference(tableName, columnName) {
+    return Object.freeze({
+        kind: 'column',
+        [columnMetadataKey]: Object.freeze({
+            tableName,
+            columnName,
+            qualifiedName: tableName + '.' + columnName,
+        }),
+    });
+}
+function resolveTableColumns(tableName, columns) {
+    let columnDefinitions = {};
+    for (let columnName in columns) {
+        if (!Object.prototype.hasOwnProperty.call(columns, columnName)) {
+            continue;
+        }
+        let column = columns[columnName];
+        if (!(column instanceof ColumnBuilder)) {
+            throw new Error('Invalid column "' +
+                columnName +
+                '" for table "' +
+                tableName +
+                '". Expected a column(...) builder');
+        }
+        columnDefinitions[columnName] = column.build();
+    }
+    return Object.freeze(columnDefinitions);
+}
+/**
+ * Defines a one-to-many relation from `source` to `target`.
+ * @param source Source table.
+ * @param target Target table.
+ * @param relationOptions Relation key configuration.
+ * @returns A relation descriptor.
+ */
+export function hasMany(source, target, relationOptions) {
+    let sourceKey = normalizeKeySelector(source, relationOptions?.targetKey, 'targetKey', getTablePrimaryKey(source));
+    let targetKey = normalizeKeySelector(target, relationOptions?.foreignKey, 'foreignKey', [
+        inferForeignKey(getTableName(source)),
+    ]);
+    assertKeyLengths(getTableName(source), getTableName(target), sourceKey, targetKey);
+    return createRelation({
+        relationKind: 'hasMany',
+        cardinality: 'many',
+        sourceTable: source,
+        targetTable: target,
+        sourceKey,
+        targetKey,
+    });
+}
+/**
+ * Defines a one-to-one relation from `source` to `target` where the foreign key lives on `target`.
+ * @param source Source table.
+ * @param target Target table.
+ * @param relationOptions Relation key configuration.
+ * @returns A relation descriptor.
+ */
+export function hasOne(source, target, relationOptions) {
+    let sourceKey = normalizeKeySelector(source, relationOptions?.targetKey, 'targetKey', getTablePrimaryKey(source));
+    let targetKey = normalizeKeySelector(target, relationOptions?.foreignKey, 'foreignKey', [
+        inferForeignKey(getTableName(source)),
+    ]);
+    assertKeyLengths(getTableName(source), getTableName(target), sourceKey, targetKey);
+    return createRelation({
+        relationKind: 'hasOne',
+        cardinality: 'one',
+        sourceTable: source,
+        targetTable: target,
+        sourceKey,
+        targetKey,
+    });
+}
+/**
+ * Defines a one-to-one relation from `source` to `target`.
+ * @param source Source table.
+ * @param target Target table.
+ * @param relationOptions Relation key configuration.
+ * @returns A relation descriptor.
+ */
+export function belongsTo(source, target, relationOptions) {
+    let sourceKey = normalizeKeySelector(source, relationOptions?.foreignKey, 'foreignKey', [
+        inferForeignKey(getTableName(target)),
+    ]);
+    let targetKey = normalizeKeySelector(target, relationOptions?.targetKey, 'targetKey', getTablePrimaryKey(target));
+    assertKeyLengths(getTableName(source), getTableName(target), sourceKey, targetKey);
+    return createRelation({
+        relationKind: 'belongsTo',
+        cardinality: 'one',
+        sourceTable: source,
+        targetTable: target,
+        sourceKey,
+        targetKey,
+    });
+}
+/**
+ * Defines a one-to-many relation from `source` to `target` through an intermediate relation.
+ * @param source Source table.
+ * @param target Target table.
+ * @param relationOptions Through relation configuration.
+ * @returns A relation descriptor.
+ */
+export function hasManyThrough(source, target, relationOptions) {
+    let throughRelation = relationOptions.through;
+    if (throughRelation.sourceTable !== source) {
+        throw new Error('hasManyThrough expects a through relation whose source table matches ' +
+            getTableName(source));
+    }
+    let throughTargetKey = normalizeKeysForTable(throughRelation.targetTable, relationOptions.throughTargetKey, 'throughTargetKey', getTablePrimaryKey(throughRelation.targetTable));
+    let throughForeignKey = normalizeKeySelector(target, relationOptions.throughForeignKey, 'throughForeignKey', [inferForeignKey(getTableName(throughRelation.targetTable))]);
+    assertKeyLengths(getTableName(throughRelation.targetTable), getTableName(target), throughTargetKey, throughForeignKey);
+    return createRelation({
+        relationKind: 'hasManyThrough',
+        cardinality: 'many',
+        sourceTable: source,
+        targetTable: target,
+        sourceKey: [...throughRelation.sourceKey],
+        targetKey: [...throughRelation.targetKey],
+        through: {
+            relation: throughRelation,
+            throughSourceKey: throughTargetKey,
+            throughTargetKey: throughForeignKey,
+        },
+    });
+}
+/**
+ * Convenience helper for standard snake_case timestamp columns.
+ * @returns Column-builder map for `created_at`/`updated_at`.
+ */
+export function timestamps() {
+    let timestampColumn = () => new ColumnBuilder({ type: 'timestamp' });
+    return {
+        created_at: timestampColumn(),
+        updated_at: timestampColumn(),
+    };
+}
+/**
+ * Normalizes a primary-key input into an object keyed by primary-key columns.
+ * @param table Source table.
+ * @param value Primary-key input value.
+ * @returns Primary-key object.
+ */
+export function getPrimaryKeyObject(table, value) {
+    let keys = getTablePrimaryKey(table);
+    if (keys.length === 1 && (typeof value !== 'object' || value === null || Array.isArray(value))) {
+        let key = keys[0];
+        return { [key]: value };
+    }
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        throw new Error('Composite primary keys require an object value');
+    }
+    let objectValue = value;
+    let output = {};
+    for (let key of keys) {
+        if (!(key in objectValue)) {
+            throw new Error('Missing key "' + key + '" for primary key lookup on "' + getTableName(table) + '"');
+        }
+        ;
+        output[key] = objectValue[key];
+    }
+    return output;
+}
+/**
+ * Builds a stable key for a row tuple.
+ * @param row Source row.
+ * @param columns Columns included in the tuple.
+ * @returns Stable tuple key.
+ */
+export function getCompositeKey(row, columns) {
+    let values = columns.map((column) => stableSerialize(row[column]));
+    return values.join('::');
+}
+/**
+ * Serializes values into stable string representations for key generation.
+ * @param value Value to serialize.
+ * @returns Stable serialized value.
+ */
+export function stableSerialize(value) {
+    if (value === null) {
+        return 'null';
+    }
+    if (value === undefined) {
+        return 'undefined';
+    }
+    if (typeof value === 'number' || typeof value === 'boolean' || typeof value === 'bigint') {
+        return String(value);
+    }
+    if (typeof value === 'string') {
+        return JSON.stringify(value);
+    }
+    if (value instanceof Date) {
+        return 'date:' + value.toISOString();
+    }
+    return JSON.stringify(value);
+}
+function normalizePrimaryKey(tableName, columns, primaryKey) {
+    if (primaryKey === undefined) {
+        if (!Object.prototype.hasOwnProperty.call(columns, 'id')) {
+            throw new Error('Table "' + tableName + '" must include an "id" column or an explicit primaryKey');
+        }
+        return ['id'];
+    }
+    let keys = Array.isArray(primaryKey) ? [...primaryKey] : [primaryKey];
+    if (keys.length === 0) {
+        throw new Error('Table "' + tableName + '" primaryKey must contain at least one column');
+    }
+    for (let key of keys) {
+        if (!Object.prototype.hasOwnProperty.call(columns, key)) {
+            throw new Error('Table "' + tableName + '" primaryKey column "' + key + '" does not exist');
+        }
+    }
+    return keys;
+}
+function normalizeKeySelector(table, selector, optionName, defaultValue) {
+    return normalizeKeysForTable(table, selector, optionName, defaultValue);
+}
+function normalizeKeysForTable(table, selector, optionName, defaultValue) {
+    if (selector === undefined) {
+        return [...defaultValue];
+    }
+    let keys = Array.isArray(selector) ? [...selector] : [selector];
+    if (keys.length === 0) {
+        throw new Error('Option "' + optionName + '" for table "' + getTableName(table) + '" must not be empty');
+    }
+    let columns = getTableColumns(table);
+    for (let key of keys) {
+        if (!Object.prototype.hasOwnProperty.call(columns, key)) {
+            throw new Error('Unknown column "' +
+                key +
+                '" in option "' +
+                optionName +
+                '" for table "' +
+                getTableName(table) +
+                '"');
+        }
+    }
+    return keys;
+}
+function normalizeTimestampConfig(options) {
+    if (!options) {
+        return null;
+    }
+    if (options === true) {
+        return { ...defaultTimestampConfig };
+    }
+    return {
+        createdAt: options.createdAt ?? defaultTimestampConfig.createdAt,
+        updatedAt: options.updatedAt ?? defaultTimestampConfig.updatedAt,
+    };
+}
+function assertKeyLengths(sourceTableName, targetTableName, sourceKey, targetKey) {
+    if (sourceKey.length !== targetKey.length) {
+        throw new Error('Relation key mismatch between "' +
+            sourceTableName +
+            '" (' +
+            sourceKey.join(', ') +
+            ') and "' +
+            targetTableName +
+            '" (' +
+            targetKey.join(', ') +
+            ')');
+    }
+}
+function createRelation(options) {
+    let baseModifiers = {
+        where: options.modifiers?.where ? [...options.modifiers.where] : [],
+        orderBy: options.modifiers?.orderBy ? [...options.modifiers.orderBy] : [],
+        limit: options.modifiers?.limit,
+        offset: options.modifiers?.offset,
+        with: options.modifiers?.with ? { ...options.modifiers.with } : {},
+    };
+    let relation = {
+        kind: 'relation',
+        relationKind: options.relationKind,
+        sourceTable: options.sourceTable,
+        targetTable: options.targetTable,
+        cardinality: options.cardinality,
+        sourceKey: [...options.sourceKey],
+        targetKey: [...options.targetKey],
+        through: options.through,
+        modifiers: baseModifiers,
+        where(input) {
+            let predicate = normalizeWhereInput(input);
+            return cloneRelation(relation, {
+                where: [...relation.modifiers.where, predicate],
+            });
+        },
+        orderBy(column, direction = 'asc') {
+            return cloneRelation(relation, {
+                orderBy: [
+                    ...relation.modifiers.orderBy,
+                    {
+                        column: normalizeColumnInput(column),
+                        direction,
+                    },
+                ],
+            });
+        },
+        limit(value) {
+            return cloneRelation(relation, {
+                limit: value,
+            });
+        },
+        offset(value) {
+            return cloneRelation(relation, {
+                offset: value,
+            });
+        },
+        with(relations) {
+            return cloneRelation(relation, {
+                with: {
+                    ...relation.modifiers.with,
+                    ...relations,
+                },
+            });
+        },
+    };
+    return relation;
+}
+function cloneRelation(relation, patch) {
+    return createRelation({
+        relationKind: relation.relationKind,
+        cardinality: relation.cardinality,
+        sourceTable: relation.sourceTable,
+        targetTable: relation.targetTable,
+        sourceKey: relation.sourceKey,
+        targetKey: relation.targetKey,
+        through: relation.through,
+        modifiers: {
+            where: patch.where ?? relation.modifiers.where,
+            orderBy: patch.orderBy ?? relation.modifiers.orderBy,
+            limit: patch.limit ?? relation.modifiers.limit,
+            offset: patch.offset ?? relation.modifiers.offset,
+            with: patch.with ?? relation.modifiers.with,
+        },
+    });
+}

package/dist/lib/types.d.ts

@@ -0,0 +1,4 @@
+export type Pretty<value> = {
+    [key in keyof value]: value[key];
+} & {};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/lib/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,MAAM,CAAC,KAAK,IAAI;KACzB,GAAG,IAAI,MAAM,KAAK,GAAG,KAAK,CAAC,GAAG,CAAC;CACjC,GAAG,EAAE,CAAA"}

package/dist/lib/types.js

@@ -0,0 +1 @@
+export {};

package/dist/migrations/node.d.ts

@@ -0,0 +1,2 @@
+export { loadMigrations } from '../lib/migrations-node.ts';
+//# sourceMappingURL=node.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../src/migrations/node.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAA"}

package/dist/migrations/node.js

@@ -0,0 +1 @@
+export { loadMigrations } from "../lib/migrations-node.js";

package/dist/migrations.d.ts

@@ -0,0 +1,8 @@
+export type { AlterTableBuilder, CreateMigrationInput, Migration, MigrationContext, MigrationDescriptor, MigrationDirection, MigrationJournalRow, MigrationSchema, MigrationRegistry, MigrationRunner, MigrationRunnerOptions, MigrationStatus, MigrationStatusEntry, MigrationTransactionMode, MigrateOptions, MigrateResult, KeyColumns, TableInput, } from './lib/migrations.ts';
+export { createMigration } from './lib/migrations.ts';
+export type { ColumnNamespace } from './lib/column.ts';
+export { ColumnBuilder, column } from './lib/column.ts';
+export { createMigrationRegistry } from './lib/migrations/registry.ts';
+export { createMigrationRunner } from './lib/migrations/runner.ts';
+export { parseMigrationFilename } from './lib/migrations/filename.ts';
+//# sourceMappingURL=migrations.d.ts.map

package/dist/migrations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrations.d.ts","sourceRoot":"","sources":["../src/migrations.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,iBAAiB,EACjB,oBAAoB,EACpB,SAAS,EACT,gBAAgB,EAChB,mBAAmB,EACnB,kBAAkB,EAClB,mBAAmB,EACnB,eAAe,EACf,iBAAiB,EACjB,eAAe,EACf,sBAAsB,EACtB,eAAe,EACf,oBAAoB,EACpB,wBAAwB,EACxB,cAAc,EACd,aAAa,EACb,UAAU,EACV,UAAU,GACX,MAAM,qBAAqB,CAAA;AAC5B,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AACrD,YAAY,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AACtD,OAAO,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;AACvD,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAA;AACtE,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAA;AAClE,OAAO,EAAE,sBAAsB,EAAE,MAAM,8BAA8B,CAAA"}

package/dist/migrations.js

@@ -0,0 +1,5 @@
+export { createMigration } from "./lib/migrations.js";
+export { ColumnBuilder, column } from "./lib/column.js";
+export { createMigrationRegistry } from "./lib/migrations/registry.js";
+export { createMigrationRunner } from "./lib/migrations/runner.js";
+export { parseMigrationFilename } from "./lib/migrations/filename.js";

package/dist/operators.d.ts

@@ -0,0 +1,3 @@
+export type { Predicate, WhereInput, WhereObject } from './lib/operators.ts';
+export { and, between, eq, gt, gte, ilike, inList, isNull, like, lt, lte, ne, notInList, notNull, or, } from './lib/operators.ts';
+//# sourceMappingURL=operators.d.ts.map

package/dist/operators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operators.d.ts","sourceRoot":"","sources":["../src/operators.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,SAAS,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAC5E,OAAO,EACL,GAAG,EACH,OAAO,EACP,EAAE,EACF,EAAE,EACF,GAAG,EACH,KAAK,EACL,MAAM,EACN,MAAM,EACN,IAAI,EACJ,EAAE,EACF,GAAG,EACH,EAAE,EACF,SAAS,EACT,OAAO,EACP,EAAE,GACH,MAAM,oBAAoB,CAAA"}

package/dist/operators.js

@@ -0,0 +1 @@
+export { and, between, eq, gt, gte, ilike, inList, isNull, like, lt, lte, ne, notInList, notNull, or, } from "./lib/operators.js";

package/dist/sql-helpers.d.ts

@@ -0,0 +1,3 @@
+export type { QuoteIdentifier } from './lib/sql-helpers.ts';
+export { collectColumns, isDataManipulationOperation, normalizeJoinType, quoteLiteral, quotePath, quoteTableRef, } from './lib/sql-helpers.ts';
+//# sourceMappingURL=sql-helpers.d.ts.map

package/dist/sql-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql-helpers.d.ts","sourceRoot":"","sources":["../src/sql-helpers.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAC3D,OAAO,EACL,cAAc,EACd,2BAA2B,EAC3B,iBAAiB,EACjB,YAAY,EACZ,SAAS,EACT,aAAa,GACd,MAAM,sBAAsB,CAAA"}

package/dist/sql-helpers.js

@@ -0,0 +1 @@
+export { collectColumns, isDataManipulationOperation, normalizeJoinType, quoteLiteral, quotePath, quoteTableRef, } from "./lib/sql-helpers.js";

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@remix-run/data-table",
-  "version": "0.0.0",
-  "private": false,
-  "description": "Placeholder package for future Remix data-table APIs",
+  "version": "0.2.0",
+  "description": "A typed, relational query toolkit for Remix",
+  "author": "Michael Jackson <mjijackson@gmail.com>",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -10,11 +10,60 @@
     "directory": "packages/data-table"
   },
   "homepage": "https://github.com/remix-run/remix/tree/main/packages/data-table#readme",
+  "files": [
+    "LICENSE",
+    "README.md",
+    "dist",
+    "src",
+    "!src/**/*.test.ts"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./migrations": {
+      "types": "./dist/migrations.d.ts",
+      "default": "./dist/migrations.js"
+    },
+    "./migrations/node": {
+      "types": "./dist/migrations/node.d.ts",
+      "default": "./dist/migrations/node.js"
+    },
+    "./operators": {
+      "types": "./dist/operators.d.ts",
+      "default": "./dist/operators.js"
+    },
+    "./sql-helpers": {
+      "types": "./dist/sql-helpers.d.ts",
+      "default": "./dist/sql-helpers.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/node": "^24.6.0",
+    "@typescript/native-preview": "7.0.0-dev.20251125.1",
+    "better-sqlite3": "^12.4.1"
+  },
+  "dependencies": {},
   "keywords": [
     "remix",
-    "placeholder"
+    "orm",
+    "sql",
+    "database",
+    "query-builder",
+    "relational"
   ],
-  "publishConfig": {
-    "access": "public"
+  "scripts": {
+    "build": "tsgo -p tsconfig.build.json",
+    "clean": "git clean -fdX",
+    "test": "node --test",
+    "test:coverage": "pnpm run test:coverage:core && pnpm run test:coverage:migrations",
+    "test:coverage:core": "node --experimental-test-coverage --test-coverage-include='src/lib/operators.ts' --test-coverage-include='src/lib/references.ts' --test-coverage-include='src/lib/inflection.ts' --test-coverage-include='src/lib/sql.ts' --test-coverage-include='src/lib/errors.ts' --test-coverage-lines=90 --test-coverage-branches=90 --test-coverage-functions=90 --test ./src/lib/operators.test.ts ./src/lib/references.test.ts ./src/lib/inflection.test.ts ./src/lib/sql.test.ts ./src/lib/errors.test.ts",
+    "test:coverage:migrations": "node --experimental-test-coverage --test-coverage-include='src/lib/migrations.ts' --test-coverage-lines=90 --test-coverage-branches=90 --test-coverage-functions=90 --test ./src/lib/migrations.test.ts",
+    "typecheck": "tsgo --noEmit"
   }
-}
+}