firstly 0.10.5 → 0.10.6

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # firstly
 
+## 0.10.6
+
+### Patch Changes
+
+- [#383](https://github.com/jycouet/firstly/pull/383) [`3d0353b`](https://github.com/jycouet/firstly/commit/3d0353b176afd765883c50f6bc10c352b752df28) Thanks [@jycouet](https://github.com/jycouet)! - sqlAdmin drift: entities in a non-`public` schema (e.g. `ff_auth.ba-accounts`) are checked in their own schema, a table not created yet is reported as `missing` instead of failing the whole apply, and errors show the real message and failing statement (no more `[object Object]`).
+
 ## 0.10.5
 
 ### Patch Changes

package/esm/mail/ui/LastMails.svelte

@@ -3,6 +3,7 @@
 
 	import { remult, repo } from 'remult'
 
+	import { errorMessage } from '../../core/helper.js'
 	import { Mail } from '../Mail'
 	import { Roles_Mail } from '../Roles_Mail'
 
@@ -28,7 +29,7 @@
 		try {
 			mails = await repo(Mail).find({ limit })
 		} catch (e) {
-			error = e instanceof Error ? e.message : String(e)
+			error = errorMessage(e)
 		} finally {
 			isLoading = false
 		}

package/esm/sqlAdmin/server/drift/catalog.d.ts

@@ -0,0 +1,4 @@
+import type { SqlDatabase } from 'remult';
+export declare function execStmt(db: SqlDatabase, sql: string): Promise<import("remult").SqlResult>;
+/** Live tables as `tableKey`s: an entity's table may never have been created (no migration run yet). */
+export declare function liveTables(db: SqlDatabase): Promise<Set<string>>;

package/esm/sqlAdmin/server/drift/catalog.js

@@ -0,0 +1,25 @@
+import { enrichSqlError } from '../sqlError';
+import { tableKeySql, USER_SCHEMA_SQL } from './ident';
+// A drift apply runs many statements in one transaction: without the statement, a
+// bare "could not create unique index" can't be traced back to its table.
+export async function execStmt(db, sql) {
+    try {
+        return await db.createCommand().execute(sql);
+    }
+    catch (err) {
+        const enriched = await enrichSqlError(db, err, sql);
+        const msg = enriched instanceof Error ? enriched.message : String(enriched);
+        throw new Error(`${msg}\n\nWhile running: ${sql.trim()}\nNothing was applied (rolled back).`, {
+            cause: err,
+        });
+    }
+}
+/** Live tables as `tableKey`s: an entity's table may never have been created (no migration run yet). */
+export async function liveTables(db) {
+    const res = await db.createCommand().execute(`
+		SELECT ${tableKeySql('table_schema', 'table_name')} AS table_key
+		FROM information_schema.tables
+		WHERE ${USER_SCHEMA_SQL('table_schema')} AND table_type = 'BASE TABLE';
+	`);
+    return new Set(res.rows.map((r) => r.table_key));
+}

package/esm/sqlAdmin/server/drift/createIndex.d.ts

@@ -14,6 +14,8 @@ export type IndexOptions = {
 export declare function formatCreateIndex(o: {
     name: string;
     table: string;
+    /** Omit for the search path (usually `public`). */
+    schema?: string;
     columns: string[];
     unique?: boolean;
     concurrently?: boolean;

package/esm/sqlAdmin/server/drift/createIndex.js

@@ -14,7 +14,8 @@ export function formatCreateIndex(o) {
         parts.push('CONCURRENTLY');
     if (o.ifNotExists)
         parts.push('IF NOT EXISTS');
-    parts.push(wrap(o.name), 'ON', wrap(o.table), `(${o.columns.map(wrap).join(', ')})`);
+    const table = o.schema ? `${wrap(o.schema)}.${wrap(o.table)}` : wrap(o.table);
+    parts.push(wrap(o.name), 'ON', table, `(${o.columns.map(wrap).join(', ')})`);
     return parts.join(' ') + ';';
 }
 /**

package/esm/sqlAdmin/server/drift/ident.d.ts

@@ -1,2 +1,18 @@
 /** pg catalog / metadata names can come back quoted or schema-qualified. */
 export declare const stripIdent: (name: string) => string;
+/**
+ * Table key shared by metadata and catalog sides of every diff: bare name in `public`,
+ * `schema.name` elsewhere - so an entity in another schema is neither lost nor
+ * mistaken for a same-named `public` table.
+ */
+export declare function tableKey(dbName: string): string;
+/** Same key, computed in SQL from a schema and a table column. */
+export declare const tableKeySql: (schema: string, table: string) => string;
+export declare function splitKey(key: string): {
+    schema?: string;
+    table: string;
+};
+/** Quoted, schema-qualified SQL reference for a `tableKey`. */
+export declare function quoteTable(key: string): string;
+/** Schemas the drift checks read: every user schema, not the system ones. */
+export declare const USER_SCHEMA_SQL: (schema: string) => string;

package/esm/sqlAdmin/server/drift/ident.js

@@ -1,2 +1,24 @@
 /** pg catalog / metadata names can come back quoted or schema-qualified. */
 export const stripIdent = (name) => name.replaceAll('"', '').split('.').pop();
+/**
+ * Table key shared by metadata and catalog sides of every diff: bare name in `public`,
+ * `schema.name` elsewhere - so an entity in another schema is neither lost nor
+ * mistaken for a same-named `public` table.
+ */
+export function tableKey(dbName) {
+    const [name, schema] = dbName.replaceAll('"', '').split('.').toReversed();
+    return schema && schema !== 'public' ? `${schema}.${name}` : name;
+}
+/** Same key, computed in SQL from a schema and a table column. */
+export const tableKeySql = (schema, table) => `CASE WHEN ${schema} = 'public' THEN ${table} ELSE ${schema} || '.' || ${table} END`;
+export function splitKey(key) {
+    const dot = key.indexOf('.');
+    return dot === -1 ? { table: key } : { schema: key.slice(0, dot), table: key.slice(dot + 1) };
+}
+/** Quoted, schema-qualified SQL reference for a `tableKey`. */
+export function quoteTable(key) {
+    const { schema, table } = splitKey(key);
+    return schema ? `"${schema}"."${table}"` : `"${table}"`;
+}
+/** Schemas the drift checks read: every user schema, not the system ones. */
+export const USER_SCHEMA_SQL = (schema) => `${schema} NOT IN ('pg_catalog', 'information_schema') AND ${schema} NOT LIKE 'pg\\_toast%'`;

package/esm/sqlAdmin/server/drift/nullable.js

@@ -1,6 +1,7 @@
 import { repo } from 'remult';
 import { getRelationFieldInfo } from 'remult/internals';
-import { stripIdent } from './ident';
+import { execStmt } from './catalog';
+import { quoteTable, stripIdent, tableKey, tableKeySql, USER_SCHEMA_SQL } from './ident';
 import { planNullableDrift, } from './planNullableDrift';
 // Only a text column has an empty value that is unambiguously "unset". A numeric or
 // boolean default (0 / false) may be genuine data, so those columns get their
@@ -31,7 +32,7 @@ export async function syncNullable(db, entities, opts) {
         const meta = repo(ent).metadata;
         if (meta.options.sqlExpression)
             continue; // views: no real table
-        const table = stripIdent(meta.dbName);
+        const table = tableKey(meta.dbName);
         for (const field of meta.fields.toArray()) {
             if (getRelationFieldInfo(field))
                 continue; // FK scalars are declared by their own field
@@ -41,13 +42,13 @@ export async function syncNullable(db, entities, opts) {
         }
     }
     const res = await db.createCommand().execute(`
-		SELECT table_name, column_name, is_nullable, column_default, data_type
+		SELECT ${tableKeySql('table_schema', 'table_name')} AS table_key, column_name, is_nullable, column_default, data_type
 		FROM information_schema.columns
-		WHERE table_schema = 'public'
-		ORDER BY table_name, ordinal_position;
+		WHERE ${USER_SCHEMA_SQL('table_schema')}
+		ORDER BY table_key, ordinal_position;
 	`);
     const current = res.rows.map((row) => ({
-        table: row.table_name,
+        table: row.table_key,
         column: row.column_name,
         isNullable: row.is_nullable === 'YES',
         hasDefault: row.column_default != null,
@@ -63,15 +64,13 @@ export async function syncNullable(db, entities, opts) {
             .map((c) => drifted.get(`${c.table}.${c.column}`))
             .filter((p) => !!p);
         for (const p of fixed) {
-            const col = `ALTER TABLE "${p.table}" ALTER COLUMN "${p.column}"`;
+            const col = `ALTER TABLE ${quoteTable(p.table)} ALTER COLUMN "${p.column}"`;
             if (p.dropDefault)
-                await db.createCommand().execute(`${col} DROP DEFAULT;`);
+                await execStmt(db, `${col} DROP DEFAULT;`);
             if (p.dropNotNull)
-                await db.createCommand().execute(`${col} DROP NOT NULL;`);
+                await execStmt(db, `${col} DROP NOT NULL;`);
             if (p.blankToNull) {
-                await db
-                    .createCommand()
-                    .execute(`UPDATE "${p.table}" SET "${p.column}" = NULL WHERE "${p.column}" = '';`);
+                await execStmt(db, `UPDATE ${quoteTable(p.table)} SET "${p.column}" = NULL WHERE "${p.column}" = '';`);
             }
         }
     }

package/esm/sqlAdmin/server/drift/orphanColumns.js

@@ -1,6 +1,7 @@
 import { repo } from 'remult';
 import { getRelationFieldInfo } from 'remult/internals';
-import { stripIdent } from './ident';
+import { execStmt } from './catalog';
+import { quoteTable, stripIdent, tableKey, tableKeySql, USER_SCHEMA_SQL } from './ident';
 import { planDropColumns } from './planDropColumns';
 /**
  * Audit - and optionally drop a selected subset of - orphan columns: live DB
@@ -45,20 +46,20 @@ export async function dropColumns(db, entities, opts) {
                 continue; // computed, no stored column
             columns.push(stripIdent(field.dbName));
         }
-        known.push({ table: stripIdent(meta.dbName), columns });
+        known.push({ table: tableKey(meta.dbName), columns });
     }
     // Live columns per table from the catalog, in ordinal order.
     const res = await db.createCommand().execute(`
-		SELECT table_name, column_name
+		SELECT ${tableKeySql('table_schema', 'table_name')} AS table_key, column_name
 		FROM information_schema.columns
-		WHERE table_schema = 'public'
-		ORDER BY table_name, ordinal_position;
+		WHERE ${USER_SCHEMA_SQL('table_schema')}
+		ORDER BY table_key, ordinal_position;
 	`);
     const liveByTable = new Map();
     for (const row of res.rows) {
-        const list = liveByTable.get(row.table_name) ?? [];
+        const list = liveByTable.get(row.table_key) ?? [];
         list.push(row.column_name);
-        liveByTable.set(row.table_name, list);
+        liveByTable.set(row.table_key, list);
     }
     const current = Array.from(liveByTable, ([table, columns]) => ({ table, columns }));
     const plans = planDropColumns(current, known);
@@ -69,7 +70,7 @@ export async function dropColumns(db, entities, opts) {
         // raw client input, so the interpolated identifiers are trusted.
         dropped = opts.columns.filter((c) => orphan.has(`${c.table}.${c.column}`));
         for (const { table, column } of dropped) {
-            await db.createCommand().execute(`ALTER TABLE "${table}" DROP COLUMN "${column}";`);
+            await execStmt(db, `ALTER TABLE ${quoteTable(table)} DROP COLUMN "${column}";`);
         }
     }
     return { applied: opts?.apply ?? false, plans, dropped };

package/esm/sqlAdmin/server/drift/planPkSync.d.ts

@@ -17,7 +17,7 @@ export type PkDesired = {
     table: string;
     cols: string[];
 };
-type PkAction = 'ok' | 'create' | 'migrate';
+type PkAction = 'ok' | 'create' | 'migrate' | 'missing';
 export type PkPlan = {
     table: string;
     before: string[];
@@ -30,7 +30,8 @@ export type PkPlan = {
  * in `desired` (firstly infra, views, etc.) are left alone - we only manage what
  * an entity's `id` config describes. Several entities can share one table (a
  * light projection + the full row on the same `dbName`) - one plan per table,
- * first declaration wins, so the UI can key rows by table.
+ * first declaration wins, so the UI can key rows by table. `tables` is every live
+ * table: an entity whose table was never created is `missing`, not a PK to add.
  */
-export declare function planPkSync(current: PkCurrent[], desired: PkDesired[]): PkPlan[];
+export declare function planPkSync(current: PkCurrent[], desired: PkDesired[], tables: ReadonlySet<string>): PkPlan[];
 export {};

package/esm/sqlAdmin/server/drift/planPkSync.js

@@ -1,11 +1,4 @@
-/**
- * Pure planner: diff the live PRIMARY KEYs against what the entity `id` config
- * wants, and emit the minimal ALTER plan. No DB access here - the controller
- * feeds it the catalog snapshot + the metadata-derived target, runs the SQL.
- *
- * Why this exists: Remult only sets a table's PK on first creation and never
- * ALTERs it, so a later `id` change is silently ignored on long-lived DBs.
- */
+import { quoteTable } from './ident';
 const ident = (name) => `"${name}"`;
 const cols = (names) => names.map(ident).join(', ');
 const sameOrder = (a, b) => a.length === b.length && a.every((c, i) => c === b[i]);
@@ -14,21 +7,24 @@ const sameOrder = (a, b) => a.length === b.length && a.every((c, i) => c === b[i
  * in `desired` (firstly infra, views, etc.) are left alone - we only manage what
  * an entity's `id` config describes. Several entities can share one table (a
  * light projection + the full row on the same `dbName`) - one plan per table,
- * first declaration wins, so the UI can key rows by table.
+ * first declaration wins, so the UI can key rows by table. `tables` is every live
+ * table: an entity whose table was never created is `missing`, not a PK to add.
  */
-export function planPkSync(current, desired) {
+export function planPkSync(current, desired, tables) {
     const byTable = new Map(current.map((c) => [c.table, c]));
     const seen = new Set();
     return desired.flatMap(({ table, cols: after }) => {
         if (seen.has(table))
             return [];
         seen.add(table);
+        if (!tables.has(table))
+            return [{ table, before: [], after, action: 'missing', sql: [] }];
         return [planTable(byTable.get(table), table, after)];
     });
 }
 function planTable(cur, table, after) {
     const before = cur?.cols ?? [];
-    const addPk = `ALTER TABLE ${ident(table)} ADD PRIMARY KEY (${cols(after)});`;
+    const addPk = `ALTER TABLE ${quoteTable(table)} ADD PRIMARY KEY (${cols(after)});`;
     if (!cur)
         return { table, before, after, action: 'create', sql: [addPk] };
     if (sameOrder(cur.cols, after))
@@ -38,6 +34,6 @@ function planTable(cur, table, after) {
         before,
         after,
         action: 'migrate',
-        sql: [`ALTER TABLE ${ident(table)} DROP CONSTRAINT ${ident(cur.constraintName)};`, addPk],
+        sql: [`ALTER TABLE ${quoteTable(table)} DROP CONSTRAINT ${ident(cur.constraintName)};`, addPk],
     };
 }

package/esm/sqlAdmin/server/drift/primaryKeys.js

@@ -1,5 +1,6 @@
 import { repo } from 'remult';
-import { stripIdent } from './ident';
+import { execStmt, liveTables } from './catalog';
+import { stripIdent, tableKey, tableKeySql, USER_SCHEMA_SQL } from './ident';
 import { planPkSync } from './planPkSync';
 /**
  * Audit - and optionally fix - PRIMARY KEY drift between the live DB and each
@@ -19,21 +20,22 @@ import { planPkSync } from './planPkSync';
 export async function reindexPrimaryKeys(db, entities, opts) {
     // Live PKs from the catalog, columns kept in constraint order.
     const res = await db.createCommand().execute(`
-		SELECT tc.table_name, tc.constraint_name, kcu.column_name
+		SELECT ${tableKeySql('tc.table_schema', 'tc.table_name')} AS table_key,
+			tc.constraint_name, kcu.column_name
 		FROM information_schema.table_constraints tc
 		JOIN information_schema.key_column_usage kcu
 			ON tc.constraint_name = kcu.constraint_name
 			AND tc.table_schema = kcu.table_schema
 		WHERE tc.constraint_type = 'PRIMARY KEY'
-			AND tc.table_schema = 'public'
-		ORDER BY tc.table_name, kcu.ordinal_position;
+			AND ${USER_SCHEMA_SQL('tc.table_schema')}
+		ORDER BY table_key, kcu.ordinal_position;
 	`);
     const byTable = new Map();
     for (const row of res.rows) {
-        let cur = byTable.get(row.table_name);
+        let cur = byTable.get(row.table_key);
         if (!cur) {
-            cur = { table: row.table_name, constraintName: row.constraint_name, cols: [] };
-            byTable.set(row.table_name, cur);
+            cur = { table: row.table_key, constraintName: row.constraint_name, cols: [] };
+            byTable.set(row.table_key, cur);
         }
         cur.cols.push(row.column_name);
     }
@@ -46,14 +48,15 @@ export async function reindexPrimaryKeys(db, entities, opts) {
         const cols = meta.idMetadata.fields.map((f) => stripIdent(f.dbName));
         if (cols.length === 0)
             continue;
-        desired.push({ table: stripIdent(meta.dbName), cols });
+        desired.push({ table: tableKey(meta.dbName), cols });
     }
-    const plans = planPkSync([...byTable.values()], desired);
+    const tables = await liveTables(db);
+    const plans = planPkSync([...byTable.values()], desired, tables);
     if (opts?.apply) {
         for (const plan of plans) {
             // Fail-fast: any throw aborts the shared transaction -> full rollback.
             for (const stmt of plan.sql)
-                await db.createCommand().execute(stmt);
+                await execStmt(db, stmt);
         }
     }
     return { applied: opts?.apply ?? false, plans };

package/esm/sqlAdmin/server/drift/relationIndexes.d.ts

@@ -13,7 +13,7 @@ export type RelIndexPlan = {
     table: string;
     columns: string[];
     name: string;
-    action: 'ok' | 'create';
+    action: 'ok' | 'create' | 'missing';
     /** name of the index already covering these columns (when action is 'ok'). */
     coveredBy: string | null;
     sql: string | null;
@@ -22,9 +22,9 @@ export type RelIndexPlan = {
  * Pure: for each (deduped) relation FK, decide whether an index is missing.
  * A relation is already covered if any existing index - including the PRIMARY KEY -
  * has those columns as its leftmost prefix, so we never propose redundant indexes
- * (e.g. an `a` index on an `(a, b)` PK table).
+ * (e.g. an `a` index on an `(a, b)` PK table). A table never created is `missing`.
  */
-export declare function planRelationIndexes(desired: RelIndexDesired[], existing: Map<string, ExistingIndex[]>): RelIndexPlan[];
+export declare function planRelationIndexes(desired: RelIndexDesired[], existing: Map<string, ExistingIndex[]>, tables: ReadonlySet<string>): RelIndexPlan[];
 /** FK columns of each entity's `toOne` relations - the indexes we'd like to exist. */
 export declare function relationIndexTargets(entities: ClassType<unknown>[]): Promise<RelIndexDesired[]>;
 /**

package/esm/sqlAdmin/server/drift/relationIndexes.js

@@ -1,16 +1,17 @@
 import { dbNamesOf, repo } from 'remult';
 import { getRelationFieldInfo } from 'remult/internals';
+import { execStmt, liveTables } from './catalog';
 import { formatCreateIndex } from './createIndex';
-import { stripIdent } from './ident';
+import { splitKey, stripIdent, tableKey, tableKeySql, USER_SCHEMA_SQL } from './ident';
 /** `want` is covered if it's a leftmost prefix of `have` (so the PK covers its own prefix). */
 const isPrefix = (want, have) => have.length >= want.length && want.every((c, i) => have[i] === c);
 /**
  * Pure: for each (deduped) relation FK, decide whether an index is missing.
  * A relation is already covered if any existing index - including the PRIMARY KEY -
  * has those columns as its leftmost prefix, so we never propose redundant indexes
- * (e.g. an `a` index on an `(a, b)` PK table).
+ * (e.g. an `a` index on an `(a, b)` PK table). A table never created is `missing`.
  */
-export function planRelationIndexes(desired, existing) {
+export function planRelationIndexes(desired, existing, tables) {
     const seen = new Set();
     const plans = [];
     for (const d of desired) {
@@ -19,6 +20,10 @@ export function planRelationIndexes(desired, existing) {
             continue;
         seen.add(key);
         const name = `FF_IX_${d.table}_${d.columns.join('_')}`;
+        if (!tables.has(d.table)) {
+            plans.push({ ...d, name, action: 'missing', coveredBy: null, sql: null });
+            continue;
+        }
         const cover = (existing.get(d.table) ?? []).find((e) => isPrefix(d.columns, e.cols));
         plans.push(cover
             ? { table: d.table, columns: d.columns, name, action: 'ok', coveredBy: cover.name, sql: null }
@@ -28,7 +33,12 @@ export function planRelationIndexes(desired, existing) {
                 name,
                 action: 'create',
                 coveredBy: null,
-                sql: formatCreateIndex({ name, table: d.table, columns: d.columns, ifNotExists: true }),
+                sql: formatCreateIndex({
+                    name,
+                    ...splitKey(d.table),
+                    columns: d.columns,
+                    ifNotExists: true,
+                }),
             });
     }
     return plans;
@@ -41,7 +51,7 @@ export async function relationIndexTargets(entities) {
         if (meta.options.sqlExpression)
             continue; // views: no real table
         const names = await dbNamesOf(ent);
-        const table = stripIdent(names.$entityName);
+        const table = tableKey(names.$entityName);
         for (const field of meta.fields.toArray()) {
             const fi = getRelationFieldInfo(field);
             if (!fi || fi.type !== 'toOne')
@@ -75,28 +85,29 @@ export async function createRelationIndexes(db, entities, opts) {
     const desired = await relationIndexTargets(entities);
     // Every existing index (incl. PK), columns in order, per table.
     const res = await db.createCommand().execute(`
-		SELECT c.relname AS table_name, i.relname AS index_name,
+		SELECT ${tableKeySql('ns.nspname', 'c.relname')} AS table_key, i.relname AS index_name,
 			array_agg(a.attname::text ORDER BY k.ord) AS cols
 		FROM pg_class c
-		JOIN pg_namespace ns ON ns.oid = c.relnamespace AND ns.nspname = 'public'
+		JOIN pg_namespace ns ON ns.oid = c.relnamespace AND ${USER_SCHEMA_SQL('ns.nspname')}
 		JOIN pg_index ix ON ix.indrelid = c.oid
 		JOIN pg_class i ON i.oid = ix.indexrelid
 		JOIN unnest(ix.indkey) WITH ORDINALITY AS k(attnum, ord) ON true
 		JOIN pg_attribute a ON a.attrelid = c.oid AND a.attnum = k.attnum
 		WHERE c.relkind = 'r' AND k.attnum > 0
-		GROUP BY c.relname, i.relname;
+		GROUP BY ns.nspname, c.relname, i.relname;
 	`);
     const existing = new Map();
     for (const row of res.rows) {
-        const list = existing.get(row.table_name) ?? [];
+        const list = existing.get(row.table_key) ?? [];
         list.push({ name: row.index_name, cols: row.cols });
-        existing.set(row.table_name, list);
+        existing.set(row.table_key, list);
     }
-    const plans = planRelationIndexes(desired, existing);
+    const tables = await liveTables(db);
+    const plans = planRelationIndexes(desired, existing, tables);
     if (opts?.apply) {
         for (const plan of plans)
             if (plan.sql)
-                await db.createCommand().execute(plan.sql);
+                await execStmt(db, plan.sql);
     }
     return { applied: opts?.apply ?? false, plans };
 }

package/esm/sqlAdmin/ui/SqlDrift.svelte

@@ -8,6 +8,7 @@
 	import { onMount } from 'svelte'
 	import { SvelteSet } from 'svelte/reactivity'
 
+	import { errorMessage } from '../../core/helper.js'
 	import { SqlDriftController, type SqlDriftFlag } from '../SqlDriftController'
 
 	// Inferred from the BackendMethods, so this never imports from `server/`.
@@ -22,7 +23,7 @@
 		try {
 			flags = await SqlDriftController.driftFlags()
 		} catch (e) {
-			flagsError = e instanceof Error ? e.message : String(e)
+			flagsError = errorMessage(e)
 		}
 	})
 
@@ -31,14 +32,15 @@
 	let pkError = $state('')
 	let pkResult = $state<PkResult | null>(null)
 
+	const PK_ORDER = { migrate: 0, create: 0, missing: 1, ok: 2 } as const
 	const pkPlans = $derived(
-		(pkResult?.plans ?? []).toSorted((a, b) => {
-			if (a.action === 'ok' && b.action !== 'ok') return 1
-			if (a.action !== 'ok' && b.action === 'ok') return -1
-			return a.table.localeCompare(b.table)
-		}),
+		(pkResult?.plans ?? []).toSorted(
+			(a, b) => PK_ORDER[a.action] - PK_ORDER[b.action] || a.table.localeCompare(b.table),
+		),
+	)
+	const pkDrift = $derived(
+		pkPlans.filter((p) => p.action === 'migrate' || p.action === 'create').length,
 	)
-	const pkDrift = $derived(pkPlans.filter((p) => p.action !== 'ok').length)
 
 	async function runPk(apply: boolean) {
 		if (
@@ -52,7 +54,7 @@
 			pkResult = await SqlDriftController.primaryKeys({ apply })
 			console.info('for AI:', JSON.stringify(pkResult))
 		} catch (e) {
-			pkError = e instanceof Error ? e.message : String(e)
+			pkError = errorMessage(e)
 		} finally {
 			pkLoading = false
 		}
@@ -63,12 +65,11 @@
 	let relError = $state('')
 	let relResult = $state<RelResult | null>(null)
 
+	const REL_ORDER = { create: 0, missing: 1, ok: 2 } as const
 	const relPlans = $derived(
-		(relResult?.plans ?? []).toSorted((a, b) => {
-			if (a.action === 'ok' && b.action !== 'ok') return 1
-			if (a.action !== 'ok' && b.action === 'ok') return -1
-			return a.name.localeCompare(b.name)
-		}),
+		(relResult?.plans ?? []).toSorted(
+			(a, b) => REL_ORDER[a.action] - REL_ORDER[b.action] || a.name.localeCompare(b.name),
+		),
 	)
 	const relMissing = $derived(relPlans.filter((p) => p.action === 'create').length)
 
@@ -80,7 +81,7 @@
 			relResult = await SqlDriftController.relationIndexes({ apply })
 			console.info('for AI:', JSON.stringify(relResult))
 		} catch (e) {
-			relError = e instanceof Error ? e.message : String(e)
+			relError = errorMessage(e)
 		} finally {
 			relLoading = false
 		}
@@ -127,7 +128,7 @@
 			selected.clear()
 			console.info('for AI:', JSON.stringify(dropResult))
 		} catch (e) {
-			dropError = e instanceof Error ? e.message : String(e)
+			dropError = errorMessage(e)
 		} finally {
 			dropLoading = false
 		}
@@ -175,7 +176,7 @@
 			nullSelected.clear()
 			console.info('for AI:', JSON.stringify(nullResult))
 		} catch (e) {
-			nullError = e instanceof Error ? e.message : String(e)
+			nullError = errorMessage(e)
 		} finally {
 			nullLoading = false
 		}
@@ -282,9 +283,10 @@
 							</td>
 							<td
 								class="border-border border-b px-3 py-2 font-mono"
-								class:text-primary={p.action !== 'ok'}
+								class:text-primary={p.action === 'migrate' || p.action === 'create'}
+								class:text-muted-foreground={p.action === 'missing'}
 							>
-								{p.action}
+								{p.action === 'missing' ? 'table missing · run migrations first' : p.action}
 							</td>
 						</tr>
 					{/each}
@@ -339,7 +341,11 @@
 								class="border-border border-b px-3 py-2 font-mono"
 								class:text-primary={p.action === 'create'}
 							>
-								{p.action === 'create' ? 'create' : `covered · ${p.coveredBy}`}
+								{p.action === 'ok'
+									? `covered · ${p.coveredBy}`
+									: p.action === 'missing'
+										? 'table missing · run migrations first'
+										: 'create'}
 							</td>
 						</tr>
 					{/each}

package/esm/sqlAdmin/ui/SqlTokens.svelte

@@ -6,6 +6,7 @@
 	 */
 	import { repo } from 'remult'
 
+	import { errorMessage } from '../../core/helper.js'
 	import { log } from '../index'
 	import { SqlAdminController } from '../SqlAdminController'
 	import {
@@ -73,7 +74,7 @@
 			name = ''
 			await refresh()
 		} catch (err) {
-			error = err instanceof Error ? err.message : String(err)
+			error = errorMessage(err)
 		} finally {
 			busy = false
 		}
@@ -86,7 +87,7 @@
 			await repo(SqlToken).update(t.id, { revokedAt: new Date() })
 			await refresh()
 		} catch (err) {
-			error = err instanceof Error ? err.message : String(err)
+			error = errorMessage(err)
 		} finally {
 			busy = false
 		}
@@ -100,7 +101,7 @@
 			await repo(SqlToken).delete(t)
 			await refresh()
 		} catch (err) {
-			error = err instanceof Error ? err.message : String(err)
+			error = errorMessage(err)
 		} finally {
 			busy = false
 		}
@@ -114,7 +115,7 @@
 			await SqlAdminController.purgeTokens()
 			await refresh()
 		} catch (err) {
-			error = err instanceof Error ? err.message : String(err)
+			error = errorMessage(err)
 		} finally {
 			busy = false
 		}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "firstly",
-  "version": "0.10.5",
+  "version": "0.10.6",
   "type": "module",
   "description": "Firstly, an opinionated Remult setup!",
   "bin": {