@minnowdb/core 0.3.0 → 0.4.0

package/dist/engine/result-wire.d.ts

@@ -65,4 +65,3 @@ export declare function encodeQueryResult(result: QueryResult): EncodedQueryResu
 export declare function encodeQueryRows(rows: readonly QueryRow[]): EncodedQueryResult;
 export declare function decodeQueryResult(payload: unknown): QueryResult;
 export declare function isWireQueryResult(value: unknown): value is WireQueryResult;
-//# sourceMappingURL=result-wire.d.ts.map

package/dist/engine/result-wire.js

@@ -1,3 +1,4 @@
+import { dateMilliseconds } from "../date-value.js";
 export function encodeQueryResult(result) {
     return encodeRows(result.columns, result.rows);
 }
@@ -115,7 +116,7 @@ function encodeColumn(name, rows) {
                 nulls[index] = 1;
             }
             else if (value instanceof Date) {
-                values[index] = value.getTime();
+                values[index] = dateMilliseconds(value);
             }
             else {
                 return encodeMixed(name, rows);
@@ -261,4 +262,3 @@ function decodeColumnValues(column, rowCount) {
     }
     return values;
 }
-//# sourceMappingURL=result-wire.js.map

package/dist/engine/schema-wire.d.ts

@@ -1,4 +1,4 @@
-import type { ColumnDefault, SqlDomain } from "../storage/index.js";
+import type { ColumnDefault, SqlDomain } from "../storage/types.js";
 import { type AnyTable, type MigrationStep, type ReferentialAction, type SchemaColumnType, type SchemaDefinition, type TableCheck, type TableForeignKey } from "./schema.js";
 /**
  * Structured-clone-safe mirror of the schema DSL. Column builders and table validators carry
@@ -93,4 +93,3 @@ export type WireMigrationStep = {
 export declare function serializeSchema(definition: SchemaDefinition<readonly AnyTable[]>): WireSchema;
 export declare function serializeMigrationSteps(steps: readonly MigrationStep[]): WireMigrationStep[];
 export declare function deserializeSchema(wire: WireSchema): SchemaDefinition<readonly AnyTable[]>;
-//# sourceMappingURL=schema-wire.d.ts.map

package/dist/engine/schema-wire.js

@@ -119,4 +119,3 @@ export function deserializeSchema(wire) {
         views: (wire.views ?? []).map(deserializeView),
     });
 }
-//# sourceMappingURL=schema-wire.js.map

package/dist/engine/schema.d.ts

@@ -1,4 +1,4 @@
-import { type ColumnDefault, type SqlDomain, type TableColumnRecord, type TableRecord } from "../storage/index.js";
+import { type ColumnDefault, type SqlDomain, type TableColumnRecord, type TableRecord } from "../storage/types.js";
 import { type Catalog, type CatalogColumn, type CatalogTable } from "./catalog.js";
 import { type QueryValue } from "./query.js";
 /**
@@ -44,8 +44,6 @@ export declare function foreignKeyName(tableName: string, columnName: string): s
 export type HasDefault<TValue> = TValue & {
     readonly __minnowHasDefault?: true;
 };
-/** Legacy compatibility marker. Schema-derived core and Kysely types read defaults directly. */
-export type Generated<TValue> = HasDefault<TValue>;
 export interface ColumnBuilder<TValue extends SchemaValue, TNullable extends boolean, TUnique extends boolean = false, THasDefault extends boolean = false, TInput extends SchemaValue = TValue> {
     readonly kind: "column";
     readonly type: SchemaColumnType;
@@ -232,11 +230,9 @@ export declare function table<const TName extends string, TColumns extends Recor
  */
 export declare function declaredForeignKeys(definition: AnyTable): Array<{
     name: string;
-    column: string;
-    columns?: string[];
+    columns: string[];
     parentTable: string;
-    parentColumn: string;
-    parentColumns?: string[];
+    parentColumns: string[];
     onDelete: ReferentialAction;
 }>;
 /**
@@ -472,4 +468,3 @@ export declare function typedTable<TTable extends AnyTable>(database: TypedTable
 /** Applies one table's alteration steps onto its current column records. */
 export declare function applyColumnSteps(record: TableRecord, steps: readonly MigrationStep[], createId: () => string): TableColumnRecord[];
 export {};
-//# sourceMappingURL=schema.d.ts.map

package/dist/engine/schema.js

@@ -1,4 +1,5 @@
-import { validateColumnDefault, validateEnumValues, validateSqlDomain, } from "../storage/index.js";
+import { copyDate, dateMilliseconds } from "../date-value.js";
+import { validateColumnDefault, validateEnumValues, validateSqlDomain, } from "../storage/types.js";
 import { compileCheckExpression, expressionColumns, validateDefaultExpression, } from "./query.js";
 import { externalSqlDomainValue, normalizeSqlDomainValue } from "./sql-domains.js";
 /**
@@ -18,10 +19,10 @@ function defaultSpecFromArg(type, value, sqlDomain) {
     }
     switch (type) {
         case "datetime":
-            if (!(value instanceof Date) || !Number.isFinite(value.getTime())) {
+            if (!(value instanceof Date) || !Number.isFinite(dateMilliseconds(value))) {
                 throw new TypeError("Default literal must be a valid Date");
             }
-            return { kind: "literal", value: new Date(value.getTime()) };
+            return { kind: "literal", value: copyDate(value) };
         case "string":
             if (typeof value !== "string")
                 throw new TypeError("Default literal must be a string");
@@ -197,7 +198,7 @@ function validateDeclaredColumnValue(definition, value, context, label) {
         return;
     }
     const matches = definition.type === "datetime"
-        ? value instanceof Date && Number.isFinite(value.getTime())
+        ? value instanceof Date && Number.isFinite(dateMilliseconds(value))
         : definition.type === "number"
             ? typeof value === "number" &&
                 Number.isFinite(value) &&
@@ -296,6 +297,7 @@ export function table(name, columns, options = {}) {
         }
     }
     const foreignKeys = options.foreignKeys ?? [];
+    const constraintNames = new Set();
     const foreignKeyNames = new Set();
     for (const key of foreignKeys) {
         validateSchemaName(key.name, "FOREIGN KEY");
@@ -303,6 +305,10 @@ export function table(name, columns, options = {}) {
             throw new TypeError(`Duplicate FOREIGN KEY in table ${name}: ${key.name}`);
         }
         foreignKeyNames.add(key.name);
+        if (constraintNames.has(key.name)) {
+            throw new TypeError(`Duplicate constraint in table ${name}: ${key.name}`);
+        }
+        constraintNames.add(key.name);
         if (key.columns.length === 0 || new Set(key.columns).size !== key.columns.length) {
             throw new TypeError(`FOREIGN KEY ${key.name} needs distinct child columns`);
         }
@@ -333,9 +339,24 @@ export function table(name, columns, options = {}) {
             throw new TypeError(`Duplicate CHECK in table ${name}: ${check.name}`);
         }
         checkNames.add(check.name);
+        if (constraintNames.has(check.name)) {
+            throw new TypeError(`Duplicate constraint in table ${name}: ${check.name}`);
+        }
+        constraintNames.add(check.name);
         if (check.sql.trim().length === 0) {
             throw new TypeError(`CHECK ${check.name} in table ${name} has no expression`);
         }
+        for (const reference of expressionColumns(compileCheckExpression(check.sql, check.name))) {
+            const pieces = reference.split(".");
+            const columnName = pieces.at(-1) ?? reference;
+            const qualifier = pieces.length > 1 ? pieces.slice(0, -1).join(".") : undefined;
+            if (qualifier !== undefined && qualifier !== name) {
+                throw new TypeError(`CHECK ${check.name} references another table: ${reference}`);
+            }
+            if (columns[columnName] === undefined) {
+                throw new TypeError(`CHECK ${check.name} names an unknown column: ${columnName}`);
+            }
+        }
     }
     return {
         kind: "table",
@@ -406,9 +427,9 @@ export function declaredForeignKeys(definition) {
             continue;
         keys.push({
             name: foreignKeyName(definition.name, columnName),
-            column: columnName,
+            columns: [columnName],
             parentTable: reference.table,
-            parentColumn: reference.column,
+            parentColumns: [reference.column],
             onDelete: reference.onDelete,
         });
     }
@@ -417,11 +438,9 @@ export function declaredForeignKeys(definition) {
         const parentColumns = [...key.references.columns];
         keys.push({
             name: key.name,
-            column: childColumns[0] ?? "",
-            ...(childColumns.length === 1 ? {} : { columns: childColumns }),
+            columns: childColumns,
             parentTable: key.references.table,
-            parentColumn: parentColumns[0] ?? "",
-            ...(parentColumns.length === 1 ? {} : { parentColumns }),
+            parentColumns,
             onDelete: key.onDelete ?? "restrict",
         });
     }
@@ -478,8 +497,8 @@ export function schema(tables, options = {}) {
                 throw new TypeError(`Duplicate FOREIGN KEY in table ${definition.name}: ${key.name}`);
             }
             declaredNames.add(key.name);
-            const childNames = key.columns ?? [key.column];
-            const parentNames = key.parentColumns ?? [key.parentColumn];
+            const childNames = key.columns;
+            const parentNames = key.parentColumns;
             const target = tables.find(({ name }) => name === key.parentTable);
             if (target === undefined ||
                 childNames.some((columnName) => !(columnName in definition.columns)) ||
@@ -584,7 +603,7 @@ export function assertColumnDroppable(record, column) {
         throw new TypeError(`The unique key cannot be dropped: ${where}. Unique-key changes need the table recreated.`);
     }
     for (const key of record.foreignKeys) {
-        if ((key.columns ?? [key.column]).includes(column.name)) {
+        if (key.columns.includes(column.name)) {
             throw new TypeError(`FOREIGN KEY ${key.name} still uses this column: ${where}`);
         }
     }
@@ -611,9 +630,8 @@ function assertColumnRenamable(catalog, record, column) {
     const where = `${record.name}.${column.name}`;
     for (const owner of catalog.tables) {
         for (const key of owner.foreignKeys) {
-            const usesChild = owner.name === record.name && (key.columns ?? [key.column]).includes(column.name);
-            const usesParent = key.parentTable === record.name &&
-                (key.parentColumns ?? [key.parentColumn]).includes(column.name);
+            const usesChild = owner.name === record.name && key.columns.includes(column.name);
+            const usesParent = key.parentTable === record.name && key.parentColumns.includes(column.name);
             if (usesChild || usesParent) {
                 throw new TypeError(`FOREIGN KEY ${key.name} prevents renaming ${where}`);
             }
@@ -652,7 +670,7 @@ function backfillsEqual(left, right) {
     if (externalLeft instanceof Date || externalRight instanceof Date) {
         return (externalLeft instanceof Date &&
             externalRight instanceof Date &&
-            externalLeft.getTime() === externalRight.getTime());
+            dateMilliseconds(externalLeft) === dateMilliseconds(externalRight));
     }
     return externalLeft === externalRight;
 }
@@ -664,18 +682,18 @@ function backfillsEqual(left, right) {
  * discipline every other unprovable change gets: an explicit error naming the fix.
  */
 function assertConstraintsUnchanged(record, definition) {
-    const describeKey = (key) => `${(key.columns ?? [key.column]).join(",")} -> ${key.parentTable}.` +
-        `${(key.parentColumns ?? [key.parentColumn]).join(",")} ON DELETE ${key.onDelete}`;
+    const describeKey = (key) => `${key.columns.join(",")} -> ${key.parentTable}.` +
+        `${key.parentColumns.join(",")} ON DELETE ${key.onDelete}`;
     const existingKeys = new Map(record.foreignKeys.map((key) => [key.name, key]));
     const declaredKeys = new Map(declaredForeignKeys(definition).map((key) => [key.name, key]));
     for (const [name, declared] of declaredKeys) {
         const existing = existingKeys.get(name);
         if (existing === undefined) {
-            throw new TypeError(`FOREIGN KEY cannot be added after creation: ${definition.name}.${declared.column}. ` +
+            throw new TypeError(`FOREIGN KEY cannot be added after creation: ${definition.name}.${declared.columns.join(",")}. ` +
                 `Existing rows are not known to satisfy it; recreate the table to add a relation.`);
         }
         if (describeKey(existing) !== describeKey(declared)) {
-            throw new TypeError(`FOREIGN KEY cannot change: ${definition.name}.${declared.column} is ` +
+            throw new TypeError(`FOREIGN KEY cannot change: ${definition.name}.${declared.columns.join(",")} is ` +
                 `${describeKey(existing)}, schema says ${describeKey(declared)}`);
         }
     }
@@ -965,7 +983,7 @@ export function typedTable(database, definition) {
     };
     const keyToken = (value) => {
         const parts = keyParts(value);
-        return JSON.stringify(parts.map((part) => part instanceof Date ? ["date", part.getTime()] : [typeof part, String(part)]));
+        return JSON.stringify(parts.map((part) => part instanceof Date ? ["date", dateMilliseconds(part)] : [typeof part, String(part)]));
     };
     const assertKeys = (keys, operation) => {
         if (keys.length === 0)
@@ -1147,8 +1165,7 @@ function columnDefaultsEqual(left, right) {
     if (left.value instanceof Date || right.value instanceof Date) {
         return (left.value instanceof Date &&
             right.value instanceof Date &&
-            left.value.getTime() === right.value.getTime());
+            dateMilliseconds(left.value) === dateMilliseconds(right.value));
     }
     return left.value === right.value;
 }
-//# sourceMappingURL=schema.js.map

package/dist/engine/sort-keys.d.ts

@@ -72,4 +72,3 @@ export declare function buildSortKeyColumn(count: number, valueAt: (index: numbe
  * is already in order before doing anything else, since a scan often arrives sorted.
  */
 export declare function sortKeyIndexes(count: number, terms: readonly SortKeyTerm[]): Uint32Array;
-//# sourceMappingURL=sort-keys.d.ts.map

package/dist/engine/sort-keys.js

@@ -1,7 +1,8 @@
+import { dateMilliseconds } from "../date-value.js";
 import { compareSqlStrings, compareSqlValues } from "./sql-semantics.js";
 /** Unwraps a datetime to the number the comparisons use; every other value passes through. */
 export function comparableSortValue(value) {
-    return value instanceof Date ? value.getTime() : value;
+    return value instanceof Date ? dateMilliseconds(value) : value;
 }
 /**
  * Extracts one term's values into a comparison-ready column. `valueAt` is called once per row,
@@ -418,4 +419,3 @@ class KeySorter {
         return compare;
     }
 }
-//# sourceMappingURL=sort-keys.js.map

package/dist/engine/sql-domains.d.ts

@@ -11,6 +11,12 @@ export declare function isExactNumeric(value: unknown): value is string;
 export declare function exactNumericValue(value: unknown, precision?: number, scale?: number): string | null;
 export declare function exactNumericBinary(operator: "+" | "-" | "*" | "/" | "%", left: unknown, right: unknown): string | null | undefined;
 export declare function exactNumericCompare(left: unknown, right: unknown): number | undefined;
+/**
+ * Serializes a JSON value while bounding traversal, nesting, and output before concatenation.
+ * Canonical mode sorts object names directly in the wire text (including integer-looking names,
+ * which JavaScript object enumeration would otherwise silently reorder).
+ */
+export declare function boundedJsonText(value: unknown, canonical: boolean, label?: string): string;
 export declare function jsonDomainValue(value: unknown, binary: boolean): string | null;
 export declare function uuidDomainValue(value: unknown): string | null;
 export declare function timeDomainValue(value: unknown): string | null;
@@ -23,4 +29,3 @@ export declare function collatedDomainValue(value: unknown, collation: unknown):
 export declare function collatedDomainCompare(left: unknown, right: unknown): number | undefined;
 export declare function externalSqlDomainValue(value: unknown): unknown;
 export declare function isSqlDomainValue(value: unknown): value is string;
-//# sourceMappingURL=sql-domains.d.ts.map