@everystack/cli 0.3.28 → 0.4.0

package/src/cli/schema-source.ts

@@ -25,7 +25,8 @@
  * Input is a `@everystack/model` ModelDescriptor (type-only — no runtime dep).
  */
 
-import type { ModelDescriptor, FieldSpec } from '@everystack/model';
+import type { ModelDescriptor, FieldSpec, DerivedDescriptor, ViewDescriptor, MaterializedViewDescriptor } from '@everystack/model';
+import { parseQualified } from './derived-source.js';
 
 /** `author_id` is the SQL identifier; `authorId` the field key. The single snake-case rule. */
 function toSnakeCase(name: string): string {
@@ -144,6 +145,7 @@ function columnModifiers(
   if (spec.defaultKind === 'now') s += '.defaultNow()';
   else if (spec.defaultKind === 'random') s += '.defaultRandom()';
   else if (spec.defaultKind === 'value') s += `.default(${defaultValueLiteral(spec.default)})`;
+  else if (spec.defaultKind === 'sql') s += `.default(sql.raw(${strLiteral(String(spec.default))}))`;
 
   if (spec.isPrimaryKey && !isComposite) s += '.primaryKey()';
 
@@ -250,6 +252,25 @@ function relationNameFragment(
 export interface CompileDrizzleSourceOptions {
   /** Reserved for parity with the DDL compiler's `schema` option. Unused in the emit. */
   schema?: string;
+  /**
+   * The declared derived layer (B6a): views/matviews that declare `fields` are emitted
+   * as typed `pgView(...)`/`pgMaterializedView(...)` `.existing()` blocks — the
+   * reconciler owns their DDL; the generated schema carries only the read shape.
+   * Relations without `fields` and non-relation kinds are skipped.
+   */
+  derived?: DerivedDescriptor[];
+}
+
+/** The derived relations that opted into typed emission, identity-sorted (deterministic). */
+function typedRelations(derived: DerivedDescriptor[]): (ViewDescriptor | MaterializedViewDescriptor)[] {
+  return derived
+    .filter((d): d is ViewDescriptor | MaterializedViewDescriptor =>
+      (d.kind === 'view' || d.kind === 'materialized view') && !!d.fields && Object.keys(d.fields).length > 0)
+    .sort((a, b) => {
+      const qa = parseQualified(a.name);
+      const qb = parseQualified(b.name);
+      return qa.schema.localeCompare(qb.schema) || qa.name.localeCompare(qb.name);
+    });
 }
 
 /**
@@ -264,14 +285,15 @@ export function compileDrizzleSource(allModels: ModelDescriptor[], _opts: Compil
   // generated schema. (The migration generator still emits its SQL + authz.) The
   // command and the drift guard both call this, so filtering here keeps them in sync.
   const models = allModels.filter((m) => !m.private);
+  const derivedRelations = typedRelations(_opts.derived ?? []);
 
   const modelsByDescriptor = new Map<ModelDescriptor, { camel: string }>();
   for (const model of models) modelsByDescriptor.set(model, { camel: toCamelCase(model.table) });
 
   // --- Collect enums (deduped by name, sorted) -----------------------------
   const enumsByName = new Map<string, readonly string[]>();
-  for (const model of models) {
-    for (const f of Object.values(model.fields)) {
+  const collectEnums = (fields: Record<string, { spec: FieldSpec }>) => {
+    for (const f of Object.values(fields)) {
       const { type, enumName, enumValues } = f.spec;
       if (type !== 'enum' || !enumName) continue;
       const values = enumValues ?? [];
@@ -281,7 +303,9 @@ export function compileDrizzleSource(allModels: ModelDescriptor[], _opts: Compil
       }
       if (!existing) enumsByName.set(enumName, values);
     }
-  }
+  };
+  for (const model of models) collectEnums(model.fields);
+  for (const rel of derivedRelations) collectEnums(rel.fields!);
   const enumNames = [...enumsByName.keys()].sort((a, b) => a.localeCompare(b));
 
   // --- Track which pg-core builders + drizzle-orm symbols are used ----------
@@ -303,6 +327,7 @@ export function compileDrizzleSource(allModels: ModelDescriptor[], _opts: Compil
       const spec = builder.spec;
       const { call, builder: pgBuilder } = baseColumnSource(toSnakeCase(key), spec);
       pgCoreBuilders.add(pgBuilder);
+      if (spec.defaultKind === 'sql') pgCoreBuilders.add('sql'); // imported from 'drizzle-orm', handled below
       const mods = columnModifiers(spec, isComposite, modelsByDescriptor);
       if (spec.isDeprecated) {
         // The contract phase (decision 13): the column stays in the database and
@@ -381,14 +406,57 @@ export function compileDrizzleSource(allModels: ModelDescriptor[], _opts: Compil
     );
   }
 
+  // --- Emit derived relation blocks (typed reads — B6a) ----------------------
+  // Views/matviews that declared `fields` become `.existing()` declarations: the
+  // reconciler owns their DDL, so drizzle never creates them — the block carries
+  // ONLY the read shape (type, nullability, array). Identity-sorted for the
+  // drift-guard byte-match; column names snake_case by the same single rule.
+  const derivedBlocks: string[] = [];
+  for (const rel of derivedRelations) {
+    const { schema, name } = parseQualified(rel.name);
+    const camel = toCamelCase(schema === 'public' ? name : `${schema}_${name}`);
+
+    const colLines: string[] = [];
+    for (const [key, builder] of Object.entries(rel.fields!)) {
+      const spec = builder.spec;
+      const { call, builder: pgBuilder } = baseColumnSource(toSnakeCase(key), spec);
+      pgCoreBuilders.add(pgBuilder);
+      // Only .array()/.notNull() can appear — defineView/defineMaterializedView
+      // reject every table-structural modifier at define time.
+      const mods = columnModifiers(spec, true, modelsByDescriptor);
+      colLines.push(`  ${key}: ${call}${mods},`);
+    }
+    const cols = `{\n${colLines.join('\n')}\n}`;
+
+    if (schema === 'public') {
+      const topFn = rel.kind === 'view' ? 'pgView' : 'pgMaterializedView';
+      pgCoreBuilders.add(topFn);
+      derivedBlocks.push(`export const ${camel} = ${topFn}(${strLiteral(name)}, ${cols}).existing();`);
+    } else {
+      const schemaFn = rel.kind === 'view' ? 'view' : 'materializedView';
+      pgCoreBuilders.add('pgSchema');
+      derivedBlocks.push(`export const ${camel} = pgSchema(${strLiteral(schema)}).${schemaFn}(${strLiteral(name)}, ${cols}).existing();`);
+    }
+  }
+
   // --- Header ----------------------------------------------------------------
-  const header = [
+  const headerLines = [
     '// GENERATED by `everystack db:generate` from models/. Do not edit.',
     '//',
     '// Cross-schema foreign keys (e.g. profiles.id -> auth.users.id) are intentionally',
     '// omitted: a Model cannot reference a table outside the model set, so the runtime',
     '// table and its relations() never carry that FK. The DB constraint stays untouched.',
-  ].join('\n');
+  ];
+  if (derivedBlocks.length) {
+    headerLines.push(
+      '//',
+      '// Derived relations (views/matviews) are declared `.existing()`: db:reconcile owns',
+      '// their DDL — these blocks carry only the read shape their descriptors declare.',
+      '// That shape is author-declared, NOT introspected: a wrong field type or',
+      '// nullability in the descriptor mistypes reads silently. Fix the descriptor.',
+    );
+  }
+  const header = headerLines.join('\n');
 
   // --- Imports ---------------------------------------------------------------
   // pg-core: sorted, enum consts are not imports (they're declared below), `sql`
@@ -422,6 +490,7 @@ export function compileDrizzleSource(allModels: ModelDescriptor[], _opts: Compil
   if (enumDecls.length) sections.push(enumDecls.join('\n'));
   for (const block of tableBlocks) sections.push(block);
   for (const block of relationBlocks) sections.push(block);
+  for (const block of derivedBlocks) sections.push(block);
 
   return sections.join('\n\n') + '\n';
 }

package/src/cli/state-apply.ts

@@ -23,6 +23,7 @@ import { introspectContract, type AuthzContract, type QueryRunner } from './auth
 import { introspectSchema, type SchemaSnapshot } from './schema-introspect.js';
 import { FUNCTIONS_SQL, contractFunctionRow } from './security-catalog.js';
 import { generateMigrationSql, HELD_DROP_PREFIX } from './migration-generate.js';
+import type { SequenceDescriptor } from '@everystack/model';
 import { fingerprintLive } from './schema-fingerprint.js';
 import { ENSURE_RECONCILER_SQL, renderSchemaLogInsert, renderSchemaLogFingerprintUpdate } from './derived-apply.js';
 
@@ -170,6 +171,8 @@ export async function applyGeneratedStatements(
 export interface StateSyncOptions extends StateApplyOptions {
   /** Passed through to the verifying re-diff so held-vs-real matches the plan. */
   allowDrops?: boolean;
+  /** Standalone sequences — the verify re-diff must see the same declared state as the plan. */
+  sequences?: SequenceDescriptor[];
 }
 
 export interface StateSyncOutcome {
@@ -228,7 +231,7 @@ export async function applyStateAndVerify(
   }
 
   const remaining = classifyGeneratedStatements(
-    generateMigrationSql(models, snapshot, { allowDrops: options.allowDrops, liveAuthz: contract }),
+    generateMigrationSql(models, snapshot, { allowDrops: options.allowDrops, liveAuthz: contract, sequences: options.sequences }),
   ).executable;
 
   return {