@atscript/db 0.1.136 → 0.1.137

package/dist/sync.mjs

@@ -1,314 +1,4 @@
-import { W as NoopLogger } from "./db-view-BrAtbaOx.mjs";
-//#region src/schema/schema-hash.ts
-/** Extracts sorted field snapshots from a readable's field descriptors. */
-function extractFieldSnapshots(fields, typeMapper) {
-	return fields.filter((f) => !f.ignored).map((f) => {
-		const snap = {
-			physicalName: f.physicalName,
-			designType: f.designType,
-			optional: f.optional,
-			isPrimaryKey: f.isPrimaryKey,
-			storage: f.storage
-		};
-		if (f.defaultValue) snap.defaultValue = f.defaultValue;
-		if (typeMapper) snap.mappedType = typeMapper(f);
-		if (f.encrypted) snap.encrypted = true;
-		return snap;
-	}).toSorted((a, b) => a.physicalName.localeCompare(b.physicalName));
-}
-/**
-* Extracts a canonical, serializable snapshot from a readable's metadata.
-* Sorted deterministically so the hash is stable across runs.
-*
-* @param readable - The table/view readable.
-* @param typeMapper - Optional adapter-specific type mapper. When provided,
-*   each field's mapped type (e.g., "VARCHAR(255)") is stored in the snapshot
-*   for precise type change detection.
-*/
-function computeTableSnapshot(readable, typeMapper, tableOptions) {
-	const fields = extractFieldSnapshots(readable.fieldDescriptors, typeMapper);
-	const indexes = [...readable.indexes.values()].map((idx) => ({
-		key: idx.key,
-		type: idx.type,
-		fields: idx.fields.map((f) => ({
-			name: f.name,
-			sort: f.sort
-		}))
-	})).toSorted((a, b) => a.key.localeCompare(b.key));
-	const foreignKeys = [...readable.foreignKeys.values()].map((fk) => ({
-		fields: [...fk.fields].toSorted(),
-		targetTable: fk.targetTable,
-		targetFields: [...fk.targetFields].toSorted(),
-		onDelete: fk.onDelete,
-		onUpdate: fk.onUpdate
-	})).toSorted((a, b) => a.fields.join(",").localeCompare(b.fields.join(",")));
-	const snapshot = {
-		tableName: readable.tableName,
-		fields,
-		indexes,
-		foreignKeys
-	};
-	if (tableOptions?.length) snapshot.tableOptions = [...tableOptions].toSorted((a, b) => a.key.localeCompare(b.key));
-	return snapshot;
-}
-/**
-* Extracts a canonical, serializable snapshot from a view's metadata.
-* Captures view plan (entry table, joins, filter, materialization) for
-* detecting view definition changes.
-*/
-function computeViewSnapshot(view) {
-	const fields = extractFieldSnapshots(view.fieldDescriptors);
-	if (view.isExternal) return {
-		tableName: view.tableName,
-		viewType: "E",
-		fields
-	};
-	const plan = view.viewPlan;
-	const qualify = (ref) => view.resolveFieldRef(ref, (n) => n);
-	const canonical = (node) => JSON.stringify(canonicalizeQueryNode(node, qualify));
-	const columns = view.getViewColumnMappings().map((m) => {
-		const col = {
-			column: m.viewColumn,
-			sourceTable: m.sourceTable,
-			sourceColumn: m.sourceColumn
-		};
-		if (m.json) {
-			col.jsonPath = JSON.stringify(m.json.path);
-			col.jsonType = m.json.type;
-		}
-		if (m.aggFn) col.aggFn = m.aggFn;
-		if (m.aggField) col.aggField = m.aggField;
-		if (m.aggFilter) col.aggFilter = canonical(m.aggFilter);
-		return col;
-	}).toSorted((a, b) => a.column < b.column ? -1 : a.column > b.column ? 1 : 0);
-	const result = {
-		tableName: view.tableName,
-		viewType: plan.materialized ? "M" : "V",
-		entryTable: plan.entryTable,
-		joinTables: plan.joins.map((j) => {
-			const join = {
-				targetTable: j.targetTable,
-				condition: canonical(j.condition)
-			};
-			if (j.kind === "left") join.kind = "left";
-			return join;
-		}),
-		columns
-	};
-	if (plan.filter) result.filterHash = fnv1a(canonical(plan.filter));
-	if (plan.having) result.havingHash = fnv1a(canonical(plan.having));
-	if (plan.materialized) result.materialized = true;
-	return {
-		...result,
-		fields
-	};
-}
-/**
-* Converts a view predicate (join condition, `@db.view.filter`,
-* `@db.view.having`) into a serializable structure whose JSON is a stable
-* function of its MEANING: field refs become `qualify(ref)` — the view's
-* `resolveFieldRef(ref, (n) => n)`, i.e. `"<table>.<field>"`, so a predicate
-* retargeted to another table with the same field name changes — operators
-* and literal values are kept as-is, `$and`/`$or` keep declaration order, and
-* no function references survive. Two identical models produce byte-identical
-* JSON.
-* @since 0.1.128
-*/
-function canonicalizeQueryNode(node, qualify) {
-	if ("$and" in node) return { and: node.$and.map((n) => canonicalizeQueryNode(n, qualify)) };
-	if ("$or" in node) return { or: node.$or.map((n) => canonicalizeQueryNode(n, qualify)) };
-	if ("$not" in node) return { not: canonicalizeQueryNode(node.$not, qualify) };
-	const comp = node;
-	const out = {
-		l: qualify(comp.left),
-		op: comp.op
-	};
-	if (comp.right !== void 0) out.r = comp.right !== null && typeof comp.right === "object" && "field" in comp.right ? { f: qualify(comp.right) } : comp.right;
-	return out;
-}
-/**
-* Computes a deterministic hash string from multiple table snapshots.
-* Uses FNV-1a for speed — not cryptographic, just needs stability + collision resistance.
-*/
-function computeSchemaHash(snapshots) {
-	const sorted = [...snapshots].toSorted((a, b) => a.tableName.localeCompare(b.tableName));
-	return fnv1a(JSON.stringify(sorted));
-}
-/**
-* Computes a hash for a single table/view snapshot.
-* Used for per-table change detection via stored snapshots.
-*/
-function computeTableHash(snapshot) {
-	return fnv1a(JSON.stringify(snapshot));
-}
-/**
-* Converts stored snapshot fields to `TExistingColumn[]` format
-* for use with `computeColumnDiff`. Used by adapters that lack
-* native column introspection (e.g., MongoDB).
-*
-* The `type` field uses `mappedType` when available (adapter-specific),
-* falling back to `designType`.
-*/
-function snapshotToExistingColumns(snapshot) {
-	return snapshot.fields.map((f) => ({
-		name: f.physicalName,
-		type: f.mappedType ?? f.designType,
-		notnull: !f.optional,
-		pk: f.isPrimaryKey,
-		dflt_value: serializeDefaultValue(f.defaultValue)
-	}));
-}
-/**
-* Extracts table options from a stored snapshot for diff comparison.
-* Used as fallback when an adapter lacks native table option introspection.
-*/
-function snapshotToExistingTableOptions(snapshot) {
-	return snapshot.tableOptions ?? [];
-}
-/** Serializes a TDbDefaultValue to a comparable string. */
-function serializeDefaultValue(dv) {
-	if (!dv) return;
-	if (dv.kind === "value") return dv.value;
-	return `fn:${dv.fn}`;
-}
-/** FNV-1a 32-bit hash → hex string */
-function fnv1a(str) {
-	let hash = 2166136261;
-	for (let i = 0; i < str.length; i++) {
-		hash ^= str.codePointAt(i);
-		hash = Math.imul(hash, 16777619);
-	}
-	return Math.trunc(hash).toString(16).padStart(8, "0");
-}
-//#endregion
-//#region src/schema/fk-diff.ts
-/** Canonical key for an FK: sorted local field names, comma-joined. */
-function fkKey(fields) {
-	return [...fields].toSorted().join(",");
-}
-/**
-* Compares desired FK constraints against stored snapshot to detect
-* additions, removals, and property changes (target table, target fields,
-* onDelete, onUpdate).
-*/
-function computeForeignKeyDiff(desired, existingSnapshot) {
-	const added = [];
-	const removed = [];
-	const changed = [];
-	const existingByKey = /* @__PURE__ */ new Map();
-	for (const fk of existingSnapshot) existingByKey.set(fkKey(fk.fields), fk);
-	const desiredKeys = /* @__PURE__ */ new Set();
-	for (const fk of desired.values()) {
-		const key = fkKey(fk.fields);
-		desiredKeys.add(key);
-		const existing = existingByKey.get(key);
-		if (!existing) added.push(fk);
-		else if (fkPropertiesDiffer(fk, existing)) changed.push({
-			desired: fk,
-			existing
-		});
-	}
-	for (const [key, fk] of existingByKey) if (!desiredKeys.has(key)) removed.push(fk);
-	return {
-		added,
-		removed,
-		changed
-	};
-}
-/** Whether the FK diff contains any changes. */
-function hasForeignKeyChanges(diff) {
-	return diff.added.length > 0 || diff.removed.length > 0 || diff.changed.length > 0;
-}
-function fkPropertiesDiffer(desired, existing) {
-	if (desired.targetTable !== existing.targetTable) return true;
-	if (fkKey(desired.targetFields) !== fkKey(existing.targetFields)) return true;
-	if ((desired.onDelete ?? void 0) !== (existing.onDelete ?? void 0)) return true;
-	if ((desired.onUpdate ?? void 0) !== (existing.onUpdate ?? void 0)) return true;
-	return false;
-}
-//#endregion
-//#region src/schema/column-diff.ts
-/**
-* Computes the difference between desired schema fields and existing database columns.
-*
-* @param desired - Field descriptors from the Atscript type (after flattening).
-* @param existing - Columns currently in the database (from introspection).
-* @param typeMapper - Optional function to map field metadata to DB-native type strings.
-*                     Receives the full field meta (design type, annotations, PK status, etc.)
-*                     so adapters can produce context-aware types (e.g., `VARCHAR(255)` from maxLength).
-*                     Required for type change detection.
-*/
-function computeColumnDiff(desired, existing, typeMapper) {
-	const existingByName = new Map(existing.map((c) => [c.name, c]));
-	const desiredByName = /* @__PURE__ */ new Map();
-	const renamedOldNames = /* @__PURE__ */ new Set();
-	const added = [];
-	const renamed = [];
-	const typeChanged = [];
-	const nullableChanged = [];
-	const defaultChanged = [];
-	const conflicts = [];
-	for (const field of desired) {
-		if (field.ignored) continue;
-		desiredByName.set(field.physicalName, field);
-		const existingCol = existingByName.get(field.physicalName);
-		if (existingCol) if (field.renamedFrom && existingByName.has(field.renamedFrom)) {
-			conflicts.push({
-				field,
-				oldName: field.renamedFrom,
-				conflictsWith: field.physicalName
-			});
-			renamedOldNames.add(field.renamedFrom);
-		} else {
-			if (typeMapper) {
-				if (typeMapper(field).toUpperCase() !== existingCol.type.toUpperCase()) typeChanged.push({
-					field,
-					existingType: existingCol.type
-				});
-			}
-			if (!field.isPrimaryKey && !existingCol.pk) {
-				const desiredNotNull = !field.optional;
-				if (existingCol.notnull !== desiredNotNull) nullableChanged.push({
-					field,
-					wasNullable: !existingCol.notnull
-				});
-			}
-			const desiredDefault = serializeDefaultValue(field.defaultValue);
-			if (existingCol.dflt_value !== void 0 && existingCol.dflt_value !== desiredDefault) defaultChanged.push({
-				field,
-				oldDefault: existingCol.dflt_value,
-				newDefault: desiredDefault
-			});
-		}
-		else if (field.renamedFrom && existingByName.has(field.renamedFrom)) {
-			renamed.push({
-				field,
-				oldName: field.renamedFrom
-			});
-			renamedOldNames.add(field.renamedFrom);
-		} else added.push(field);
-	}
-	const diff = {
-		added,
-		removed: existing.filter((c) => !desiredByName.has(c.name) && !renamedOldNames.has(c.name)),
-		renamed,
-		typeChanged,
-		nullableChanged,
-		defaultChanged,
-		conflicts
-	};
-	if (existing.length > 0) {
-		const newNameByOld = new Map(renamed.map((r) => [r.oldName, r.field.physicalName]));
-		const from = existing.filter((c) => c.pk).map((c) => newNameByOld.get(c.name) ?? c.name);
-		const to = desired.filter((f) => !f.ignored && f.isPrimaryKey).map((f) => f.physicalName);
-		if (fkKey(from) !== fkKey(to)) diff.primaryKeyChanged = {
-			from,
-			to
-		};
-	}
-	return diff;
-}
-//#endregion
+import { a as hasForeignKeyChanges, c as computeTableHash, d as snapshotToExistingColumns, f as snapshotToExistingTableOptions, i as fkKey, l as computeTableSnapshot, nt as NoopLogger, o as canonicalizeQueryNode, r as computeForeignKeyDiff, s as computeSchemaHash, t as computeColumnDiff, u as computeViewSnapshot } from "./column-diff-BwOA5101.mjs";
 //#region src/schema/table-option-diff.ts
 /**
 * Computes the difference between desired and existing table options.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atscript/db",
-  "version": "0.1.136",
+  "version": "0.1.137",
   "description": "Database adapter utilities for atscript.",
   "keywords": [
     "atscript",