@everystack/cli 0.3.27 → 0.3.28

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@everystack/cli",
-  "version": "0.3.27",
+  "version": "0.3.28",
   "description": "CLI and OTA updates for Expo apps on everystack",
   "license": "AGPL-3.0-only",
   "author": "Scalable Technology, Inc. <licensing@scalable.technology>",

package/src/cli/commands/db-sync.ts

@@ -169,6 +169,16 @@ export function buildSyncReport(run: SyncRun): string[] {
     lines.push(`· ${state.classified.notices.length} notice(s) — manual follow-ups, nothing executed for them`);
   }
 
+  // The base fingerprint is a STATE-layer fact: both endpoints are sampled around
+  // the state apply, before compute runs. Print it here, adjacent to the state
+  // section, so an empty→full move never reads as if the compute step caused it —
+  // the derived layer (functions/views/matviews) is not fingerprinted at all.
+  lines.push(
+    state.toFingerprint === state.fromFingerprint
+      ? `base fingerprint: ${short(state.toFingerprint)} (unchanged)`
+      : `base fingerprint: ${short(state.fromFingerprint)} → ${short(state.toFingerprint)} (across the state apply)`,
+  );
+
   // Compute.
   if (compute === null) {
     lines.push('· compute: no db/sql directory — derived layer not declared, skipped');
@@ -181,12 +191,7 @@ export function buildSyncReport(run: SyncRun): string[] {
     }
   }
 
-  // Fingerprint.
-  lines.push(
-    state.toFingerprint === state.fromFingerprint
-      ? `fingerprint: ${short(state.toFingerprint)} (unchanged)`
-      : `fingerprint: ${short(state.fromFingerprint)} → ${short(state.toFingerprint)}`,
-  );
+  // Verdict.
   if (run.fingerprintMatch) {
     lines.push('MATCH — the database is the state your checkout declares');
   } else if (run.stateConverged) {

package/src/cli/schema-fingerprint.ts

@@ -27,6 +27,13 @@
  *  - FUNCTIONS are excluded — they belong to the derived layer, whose own
  *    content hashes (derived-introspect) cover them. Base fingerprint + derived
  *    manifest together are the full schema state.
+ *  - Expressions (column defaults, check predicates, partial-index WHERE) hash
+ *    through the SAME normalizers the diff uses (`normalizeDefault` /
+ *    `normalizeCheck`), applied to both sides in `canonicalizeState`. Without
+ *    this the model side hashes its source form (`'primary'`, `scope = ANY(...)`)
+ *    while the live side hashes pg's deparse (`'primary'::text`,
+ *    `(scope = ANY(...))`) — the identity below breaks on any schema with a text
+ *    default, a check, or a partial index even when the diff is a no-op.
  *  - Deparse stability caveat, stated once: policy/check predicates hash as
  *    Postgres deparses them; a major-version deparser change can shift
  *    fingerprints. The version prefix plus the re-diff path keep that honest.
@@ -43,8 +50,12 @@ import type { SchemaSnapshot, TableSchema } from './schema-introspect.js';
 import type { AuthzContract, TableContract } from './authz-contract.js';
 import { compileTableSchema, compileEnums } from './schema-compile.js';
 import { compileTableContract } from './authz-compile.js';
+import { normalizeDefault, normalizeCheck } from './schema-diff.js';
 
-export const FINGERPRINT_VERSION = 1;
+// v2: expression fields (defaults, checks, partial-index WHERE) normalize through
+// the diff's pg-deparse normalizers before hashing, so the model form and the live
+// deparsed form agree — the identity `fingerprintModels === fingerprintLive` holds.
+export const FINGERPRINT_VERSION = 2;
 
 // ---------------------------------------------------------------------------
 // Canonical form.
@@ -70,13 +81,17 @@ function canonicalTable(table: TableSchema): Record<string, unknown> {
   return {
     table: table.table,
     columns: byKey(
-      table.columns.map((c) => ({ name: c.name, type: c.type, notNull: c.notNull, default: c.default })),
+      // Defaults hash SEMANTICALLY, through the same normalizer the diff uses: the Model
+      // emits `'primary'`, pg deparses it to `'primary'::text` — the same state, one hash.
+      table.columns.map((c) => ({ name: c.name, type: c.type, notNull: c.notNull, default: normalizeDefault(c.default) })),
       (c) => c.name,
     ),
     primaryKey: table.primaryKey,
     // Content, not names: a pg-default `_key` and a model-named unique are the same state.
     uniques: byKey(table.uniques.map((u) => ({ columns: u.columns })), (u) => u.columns.join(',')),
-    checks: byKey(table.checks.map((c) => ({ expr: c.expr })), (c) => c.expr),
+    // Predicates hash as the diff compares them — one layer of pg's wrapping parens dropped
+    // (`(scope = ANY (...))` == `scope = ANY (...)`), whitespace collapsed.
+    checks: byKey(table.checks.map((c) => ({ expr: normalizeCheck(c.expr) })), (c) => c.expr),
     foreignKeys: byKey(
       table.foreignKeys.map((f) => ({
         columns: f.columns, refTable: f.refTable, refColumns: f.refColumns,
@@ -86,7 +101,8 @@ function canonicalTable(table: TableSchema): Record<string, unknown> {
       (f) => stableStringify(f),
     ),
     indexes: byKey(
-      table.indexes.map((i) => ({ columns: i.columns, unique: i.unique, ...(i.where ? { where: i.where } : {}) })),
+      // Partial-index WHERE is a predicate too — normalize it the same way as a check.
+      table.indexes.map((i) => ({ columns: i.columns, unique: i.unique, ...(i.where ? { where: normalizeCheck(i.where) } : {}) })),
       (i) => stableStringify(i),
     ),
   };