@fougere/adapter-sql 0.12.0-alpha.0 → 0.12.2-alpha.0

package/src/diff/Change.ts

@@ -17,6 +17,7 @@ export async function actualState(db: Kysely<any>): Promise<SchemaState> {
     if (table.isView) continue;
     state.set(table.name, new Set(table.columns.map((column) => column.name)));
   }
+
   return state;
 }
 
@@ -57,6 +58,7 @@ export function delta(desired: TableDef[], actual: SchemaState): Change[] {
       if (column.index || (column.unique && !column.primary)) changes.push({ kind: 'createIndex', table, column });
     }
   }
+
   return changes;
 }
 
@@ -81,6 +83,7 @@ export function orderChanges(changes: Change[], dialectName: DialectName): Chang
 
   const createChanges: Change[] = ordered.map((table) => {
     const names = deferredColumnsOf.get(table.name);
+
     return names ? { kind: 'createTable', table, deferredColumns: [...names] } : { kind: 'createTable', table };
   });
   const constraintChanges: Change[] = deferred.map(({ table, column }) => ({ kind: 'addConstraint', table, column }));
@@ -95,6 +98,7 @@ export function changeSQL(change: Change, dialectName: DialectName): string {
   if (change.kind === 'createTable') {
     // Reuse the same renderer as a fresh install — one builder, no drift.
     const skip = change.deferredColumns ? new Set(change.deferredColumns) : undefined;
+
     return createTableSQL(change.table, dialectName, { skipReferences: skip });
   }
   if (change.kind === 'addConstraint') {
@@ -107,6 +111,7 @@ export function changeSQL(change: Change, dialectName: DialectName): string {
   }
   const { table, column } = change;
   const type = columnTypeFor(dialect, column, isKeyed(table, column));
+
   return compiler(dialectName)
     .schema.alterTable(table.name)
     .addColumn(column.name, sql.raw(type) as any, (col) => {
@@ -126,6 +131,7 @@ export function changeSQL(change: Change, dialectName: DialectName): string {
       // arrives later is bounded like a column that was there from the start.
       const check = checkFor(column);
       if (check) built = built.check(check);
+
       return built;
     })
     .compile().sql;
@@ -139,6 +145,7 @@ export async function planMigration(
 ): Promise<{ changes: Change[]; statements: string[] }> {
   const dialect = options?.dialect ?? 'sqlite';
   const changes = orderChanges(delta(desiredTables(app, options), await actualState(db)), dialect);
+
   return { changes, statements: changes.map((change) => changeSQL(change, dialect)) };
 }
 
@@ -153,5 +160,6 @@ export async function migrate(
   for (const statement of statements) {
     await sql.raw(statement).execute(db);
   }
+
   return changes;
 }

package/src/diff/SchemaState.ts

@@ -9,5 +9,6 @@ export async function actualState(db: Kysely<any>): Promise<SchemaState> {
     if (table.isView) continue;
     state.set(table.name, new Set(table.columns.map((column) => column.name)));
   }
+
   return state;
 }

package/src/fields/Engine.ts

@@ -1,4 +1,11 @@
-import ENTRY_FORMAT from '../adapter.schema.json' with { type: 'json' };
+import type { DialectName } from '../dialect/DialectName.js';
 
-/** The engines the format names — the one list, read off the file that states it. */
-export type Engine = keyof typeof ENTRY_FORMAT.properties.columnType.properties;
+/** The engines an entry may address: the dialects this adapter speaks, and nothing else. */
+export const ENGINES = ['sqlite', 'pg', 'mysql', 'mssql'] as const;
+
+export type Engine = (typeof ENGINES)[number];
+
+type Assert<T extends true> = T;
+
+/** A fifth dialect does not compile until `ENGINES` names it. */
+type _EnginesMatchDialects = Assert<[Exclude<DialectName, Engine>] extends [never] ? true : false>;

package/src/fields/SqlFields.ts

@@ -2,24 +2,25 @@
  * What an entity may state for THIS adapter, declared from OUTSIDE `@fougere/schema` — which names
  * no engine and no column type, and must not learn one to let this exist.
  */
-import { AdapterFieldValidator, type Shape } from '@fougere/schema';
-import ENTRY_FORMAT from '../adapter.schema.json' with { type: 'json' };
-import type { DialectName } from '../dialect/DialectName.js';
+import { Format, JsonSchemaValidator, type JsonSchema } from '@fougere/schema';
+import { ENGINES } from './Engine.js';
 import type { SqlField } from './SqlField.js';
-import type { Engine } from './Engine.js';
 
 /** What sql holds, addressed by field — the shape every augmentation of the registry takes. */
 export type SqlFields<K extends string> = Readonly<Partial<Record<K, SqlField>>>;
 
-/** Judges what an entity states under `adapters.sql`, against the format this adapter ships. */
-export const sqlEntries = AdapterFieldValidator.of(ENTRY_FORMAT as Shape);
+const ENTRY_FORMAT = Format.of('https://fougere.dev/schema/adapter/sql')
+  .key(
+    'columnType',
+    ENGINES.reduce((held, engine) => held.key(engine, Format.text), Format.of()).closed(),
+  )
+  .closed();
 
-type Assert<T extends true> = T;
-
-/** A fifth dialect does not compile until `adapter.schema.json` names it. */
-type _EnginesMatchDialects = Assert<
-  [Exclude<DialectName, Engine>] extends [never] ? true : false
->;
+/** Judges what an entity states under `adapters.sql`: the format this adapter ships, keyed by field. */
+export const sqlEntries = JsonSchemaValidator.of({
+  type: 'object',
+  additionalProperties: ENTRY_FORMAT.schema as JsonSchema,
+});
 
 declare module '@fougere/schema' {
   interface FougereEntityAdapters<K extends string> {

package/src/source/SqlSource.ts

@@ -54,6 +54,7 @@ export function createKyselySource(
   opts: SqlSourceOptions = {},
 ): SqlSource {
   const db = new Kysely<any>({ dialect: kyselyDialect, log: logQueries(opts.name ?? dialect) });
+
   return {
     db,
     dialect,

package/src/sqlite/SqliteSource.ts

@@ -24,6 +24,7 @@ export function createSqliteSource(opts: SqliteSourceOptions = {}): SqliteSource
   sqlite.pragma('journal_mode = WAL');
   sqlite.pragma('foreign_keys = ON');
   const db = new Kysely<any>({ dialect: new SqliteDialect({ database: sqlite }), log: logQueries(opts.name ?? path) });
+
   return {
     db,
     sqlite,

package/src/step/Plan.ts

@@ -45,11 +45,13 @@ function compose(held: ShapeChange[], change: ShapeChange): void {
     const at = held.findIndex((each) => each.kind === 'renamed' && each.to === change.from);
     if (at === -1) {
       held.push(change);
+
       return;
     }
     const first = held[at] as Extract<ShapeChange, { kind: 'renamed' }>;
     if (first.from === change.to) held.splice(at, 1);
     else held[at] = { ...first, to: change.to };
+
     return;
   }
 
@@ -59,6 +61,7 @@ function compose(held: ShapeChange[], change: ShapeChange): void {
   const at = held.findIndex((each) => each.kind === 'renamed' && each.to === field);
   if (at === -1) {
     held.push(change);
+
     return;
   }
 
@@ -119,6 +122,7 @@ function realise(
       if (!change.required) return {};
       const column = target.columns.find((each) => each.field === change.field);
       if (column?.default !== undefined) return {};
+
       return {
         entity,
         field: change.field,
@@ -128,6 +132,7 @@ function realise(
 
     case 'required':
       if (!change.to) return {}; // Loosening is the engine's business, and no row is at risk.
+
       return {
         entity,
         field: change.field,
@@ -165,6 +170,7 @@ function restated(entity: string, change: Extract<ShapeChange, { kind: 'restated
     const was = literalOf(change.from);
     const is = literalOf(change.to);
     if (was === is) return {};
+
     return refuse(`default moved ${show(was)} → ${show(is)} — the table keeps the old one, and nothing here alters a DEFAULT`);
   }
 
@@ -180,12 +186,14 @@ function restated(entity: string, change: Extract<ShapeChange, { kind: 'restated
   // What is left is the index, and only its appearance: the additive pass proposes every
   // declared index at every boot, and nothing has ever dropped one.
   if (from.index && !to.index) return refuse(`index gone — nothing drops an index today, so the table keeps it`);
+
   return {};
 }
 
 /** The value a lifecycle declares at create, when it declares one — what reaches DEFAULT. */
 function literalOf(rules: { create?: unknown } | undefined): unknown {
   const create = rules?.create;
+
   return create && typeof create === 'object' && 'value' in create ? (create as { value: unknown }).value : undefined;
 }
 
@@ -194,6 +202,7 @@ const show = (value: unknown): string => (value === undefined ? 'none' : JSON.st
 /** Has the table already moved? Read off the columns themselves. */
 function done(change: StepChange, columns: Set<string> | undefined): boolean {
   if (!columns) return false;
+
   return change.kind === 'renameColumn'
     ? !columns.has(change.from) && columns.has(change.to)
     : !columns.has(change.column);
@@ -202,6 +211,7 @@ function done(change: StepChange, columns: Set<string> | undefined): boolean {
 /** One statement per change — the same rule `migrate` follows: no driver here batches. */
 export function stepSQL(change: StepChange, dialectName: DialectName = 'sqlite'): string {
   const alter = compiler(dialectName).schema.alterTable(change.table);
+
   return change.kind === 'renameColumn'
     ? alter.renameColumn(change.from, change.to).compile().sql
     : alter.dropColumn(change.column).compile().sql;
@@ -222,5 +232,6 @@ export async function applyStep(plan: Plan, db: Kysely<any>, dialectName: Dialec
     await sql.raw(statement).execute(db);
     run.push(statement);
   }
+
   return run;
 }

package/src/table/TableDef.ts

@@ -1,5 +1,5 @@
 import { Lifecycle, Role } from '@fougere/schema';
-import { Shapes, lowerFirst, type Field, type SchemaView } from '@fougere/schema';
+import { SchemaError, Shapes, dotted, lowerFirst, type Field, type SchemaView } from '@fougere/schema';
 import { boundsOf } from '../check.js';
 import { type SqlField } from '../fields/SqlField.js';
 import { sqlEntries } from '../fields/SqlFields.js';
@@ -17,6 +17,8 @@ export interface TableDef {
   compositePrimary: string[];
   /** Column groups unique together, from `entity(fields, { unique: [...] })`. */
   uniqueGroups: string[][];
+  /** Column groups indexed together, from `entity(fields, { index: [...] })`. */
+  indexGroups: string[][];
 }
 
 /** camelCase → snake_case */
@@ -29,15 +31,16 @@ export function toSnakeCase(str: string): string {
  * other field becomes exactly one column.
  */
 function isStored(field: Field): boolean {
-  return !Role.of(field).isCollection;
+  return !Role.of(field).isCollection();
 }
 
 /** The target's primary key column. */
 function primaryColumnOf(target: Partial<SchemaView>): string {
   if (typeof target.getFields !== 'function') return 'id';
   for (const [name, field] of Object.entries(target.getFields())) {
-    if (Role.of(field).isPrimary) return toSnakeCase(name);
+    if (Role.of(field).isPrimary()) return toSnakeCase(name);
   }
+
   return 'id'; // declared no primary() field — defensive, shouldn't happen
 }
 
@@ -49,7 +52,7 @@ function referenceFor(
   hosted?: HostedNames,
 ): ColumnReference | undefined {
   const role = Role.of(field);
-  if (!role.isReference) return undefined;
+  if (!role.isReference()) return undefined;
   const target = role.target as Partial<SchemaView> & { name?: string };
   const mapped = tableNameOf?.get(target as SchemaView);
   if (mapped === undefined && hosted !== undefined) {
@@ -77,6 +80,7 @@ function referenceFor(
   }
   const table = mapped ?? resolve(lowerFirst(target.name ?? ''));
   const column = primaryColumnOf(target);
+
   return role.onDelete ? { table, column, onDelete: role.onDelete } : { table, column };
 }
 
@@ -98,7 +102,7 @@ function toColumn(
     name: toSnakeCase(fieldName),
     type: Shapes.typeOf(field.shape),
     nullable,
-    primary: Role.of(field).isPrimary,
+    primary: Role.of(field).isPrimary(),
   };
   const bounds = boundsOf(base as Record<string, unknown> | undefined);
   if (bounds) column.bounds = bounds;
@@ -108,11 +112,12 @@ function toColumn(
   // redundant constraint on every engine. So would indexing what `unique` constrains.
   // Only a constraint of ONE becomes a column constraint; a group of several is a table
   // constraint, emitted once from `uniqueGroups` rather than once per member column.
-  if (Role.of(field).isUnique && !column.primary) column.unique = true;
-  if (Role.of(field).isIndexed && !column.primary && !column.unique) column.index = true;
+  if (Role.of(field).isUnique() && !column.primary) column.unique = true;
+  if (Role.of(field).isIndexed() && !column.primary && !column.unique) column.index = true;
   const references = referenceFor(field, resolve, tableNameOf, hosted);
   if (references) column.references = references;
   if (stated) column.stated = stated;
+
   return column;
 }
 
@@ -125,7 +130,10 @@ export function toTable(tableName: string, schema: SchemaView, relations?: Relat
   // Judged HERE and not at `entity()`: this runs at boot, after every import, so the
   // format is always loaded. A validator registered with `schema` would depend on which
   // module was imported first.
-  sqlEntries.assert(configuration, `${schema.name}.adapters.sql`);
+  const refusal = configuration === undefined
+    ? undefined
+    : sqlEntries.refusalOf(configuration, [`${schema.name}.adapters.sql`]);
+  if (refusal) throw new SchemaError(`${dotted(refusal.path)}: ${refusal.message}`);
   const columns: ColumnDef[] = [];
   for (const [fieldName, field] of Object.entries(fields)) {
     if (!isStored(field)) continue;
@@ -136,7 +144,7 @@ export function toTable(tableName: string, schema: SchemaView, relations?: Relat
   // Declared in field names, realized in column names — and a group naming a field the
   // storage does not keep is not enforceable, so it is dropped rather than emitted against
   // a column that will not exist.
-  const uniqueGroups = (schema.getUnique() ?? [])
+  const realized = (groups: readonly (readonly string[])[]) => groups
     .map((group) => group.map(toSnakeCase))
     .filter((members) => members.every((column) => stored.has(column)));
 
@@ -144,7 +152,8 @@ export function toTable(tableName: string, schema: SchemaView, relations?: Relat
     name: tableName,
     columns,
     compositePrimary: primaries.length > 1 ? primaries : [],
-    uniqueGroups,
+    uniqueGroups: realized(schema.getUnique() ?? []),
+    indexGroups: realized(schema.getIndex() ?? []),
   };
 }
 
@@ -156,7 +165,9 @@ export function isKeyed(table: TableDef, column: ColumnDef): boolean {
   return column.primary
     || column.unique === true
     || column.index === true
-    || table.compositePrimary.includes(column.name);
+    || table.compositePrimary.includes(column.name)
+    || table.indexGroups.some((group) => group.includes(column.name))
+    || table.uniqueGroups.some((group) => group.includes(column.name));
 }
 
 // ─── App-wide entity collection — shared by generateSQL and desiredTables ──
@@ -205,6 +216,7 @@ export function toTables(app: AppLike, resolve: (name: string) => string): Table
   const hosted = app.elsewhere
     ? { here: new Set(entries.map((entry) => lowerFirst(entry.name))), elsewhere: new Set(app.elsewhere.map(lowerFirst)) }
     : undefined;
+
   return entries.map((entry) => toTable(resolve(entry.name), entry.entityClass, { resolve, tableNameOf, hosted }));
 }
 

package/src/values.ts

@@ -52,6 +52,7 @@ const MAX_SAFE = BigInt(Number.MAX_SAFE_INTEGER);
 function nullSafe(codec: ValueCodec): ValueCodec {
   const pass = (fn: (v: unknown) => unknown) => (v: unknown) =>
     v === null || v === undefined ? v : fn(v);
+
   return { write: pass(codec.write), read: pass(codec.read) };
 }
 
@@ -82,5 +83,6 @@ export function codecsOf(columns: { field: string; type?: ShapeType }[]): Map<st
     const codec = codecFor(column.type);
     if (codec !== identity) codecs.set(column.field, codec);
   }
+
   return codecs;
 }

package/dist/adapter.schema.json

@@ -1,16 +0,0 @@
-{
-    "type": "object",
-    "properties": {
-        "columnType": {
-            "type": "object",
-            "properties": {
-                "sqlite": { "type": "string" },
-                "pg": { "type": "string" },
-                "mysql": { "type": "string" },
-                "mssql": { "type": "string" }
-            },
-            "additionalProperties": false
-        }
-    },
-    "additionalProperties": false
-}

package/src/adapter.schema.json

@@ -1,16 +0,0 @@
-{
-  "type": "object",
-  "properties": {
-    "columnType": {
-      "type": "object",
-      "properties": {
-        "sqlite": { "type": "string" },
-        "pg": { "type": "string" },
-        "mysql": { "type": "string" },
-        "mssql": { "type": "string" }
-      },
-      "additionalProperties": false
-    }
-  },
-  "additionalProperties": false
-}