@trylight/app 0.1.5 → 0.1.7

package/bin/light-db.mjs

@@ -1,6 +1,4 @@
 #!/usr/bin/env node
-// The app's schema files are TypeScript; tsx lets the CLI import them.
-import { register } from "tsx/esm/api";
+import "./tsx.mjs";
 
-register();
 await import("../dist/db/cli.js");

package/bin/tsx.mjs

@@ -0,0 +1,9 @@
+// The app's schema files are TypeScript; tsx lets the CLI import them. Both
+// hooks: in an app whose package.json has no "type": "module" (Next.js), Node
+// loads db/schema as CommonJS, and its extensionless imports resolve only
+// through tsx's require hook.
+import { register as registerCjs } from "tsx/cjs/api";
+import { register } from "tsx/esm/api";
+
+registerCjs();
+register();

package/dist/db/baseline.js

@@ -64,13 +64,18 @@ export async function baseline(root, databaseUrl, schemaModule = "@trylight/app/
         throw new BaselineRefused("db/ already exists. Baseline writes db/schema and db/migrations from the database, once; move db/ aside first.");
     }
     const pulled = pull(databaseUrl);
-    const { specialOpclasses, hiddenKeys } = await catalogFacts(databaseUrl);
-    if (hiddenKeys.length > 0) {
-        throw new BaselineRefused(`The database role baseline reads with can't see the keys of ${hiddenKeys.join(", ")}: Postgres shows them only to a role with REFERENCES (or more) on the table, ` +
+    const { specialOpclasses, hiddenConstraints, keys } = await catalogFacts(databaseUrl);
+    if (hiddenConstraints.length > 0) {
+        throw new BaselineRefused(`The database role baseline reads with can't see the constraints of ${hiddenConstraints.join(", ")}: Postgres shows them only to a role with REFERENCES (or more) on the table, ` +
             "which the platform grants an app's reader (scripts/grant-reader-references.ts). Nothing was written.");
     }
-    const live = pulledTables.parse(pulled.snapshot.tables);
-    const declarations = pulled.source.split(/\n(?=export const )/).slice(1).map(readDeclaration);
+    const { snapshot, added } = addKeys(pulled.snapshot, keys);
+    const live = pulledTables.parse(snapshot.tables);
+    const declarations = pulled.source
+        .split(/\n(?=export const )/)
+        .slice(1)
+        .map(readDeclaration)
+        .map((declaration) => writeKeys(declaration, added));
     const tables = declarations.filter((d) => d.kind === "pgTable" && !PLATFORM_TABLES.includes(d.dbName));
     const enums = declarations.filter((d) => d.kind === "pgEnum");
     const skipped = declarations.filter((d) => d.kind === "pgTable" && PLATFORM_TABLES.includes(d.dbName)).map((d) => d.dbName);
@@ -104,7 +109,7 @@ export async function baseline(root, databaseUrl, schemaModule = "@trylight/app/
         const full = snapshotSchema.parse(JSON.parse(JSON.stringify(generateDrizzleJson(schema, EMPTY_SNAPSHOT.id))));
         const recorded = asTheyAre(full, live);
         // What entity() says must be exactly what the database has.
-        const drift = await driftFrom(pulled.snapshot, recorded);
+        const drift = await driftFrom(snapshot, recorded);
         if (drift.length > 0) {
             throw new BaselineRefused(`db/schema can't say these tables exactly as the database has them; nothing was written. A sync would run:\n${drift.join("\n")}\n` +
                 "Change them in the old app's own migrations (the CLI's `app migrate` applies them) so they fit, then run baseline again.");
@@ -132,7 +137,11 @@ export async function baseline(root, databaseUrl, schemaModule = "@trylight/app/
         throw error;
     }
 }
-/** What pull can't tell: indexes with a non-default operator class, and tables whose keys this role can't see. */
+/**
+ * What pull can't tell: indexes with a non-default operator class, tables
+ * whose constraints this role can't see, and every table's primary key and
+ * unique constraints (see addKeys).
+ */
 async function catalogFacts(databaseUrl) {
     const sql = postgres(databaseUrl, { max: 1, onnotice: () => undefined });
     try {
@@ -149,7 +158,19 @@ async function catalogFacts(databaseUrl) {
       select c.relname as table from pg_class c join pg_namespace n on n.oid = c.relnamespace
       where n.nspname = 'public' and c.relkind in ('r', 'p') and not has_table_privilege(c.oid, 'REFERENCES')
       order by 1`;
-        return { specialOpclasses, hiddenKeys: hidden.map((row) => row.table) };
+        // pg_constraint and pg_attribute show every table's constraints to any role, owner or not.
+        const keys = await sql `
+      select t.relname as table, c.conname as name, c.contype::text as kind,
+        array_agg(a.attname::text order by k.position) as columns
+      from pg_constraint c
+      join pg_class t on t.oid = c.conrelid
+      join pg_namespace n on n.oid = t.relnamespace
+      cross join lateral unnest(c.conkey) with ordinality as k(attnum, position)
+      join pg_attribute a on a.attrelid = c.conrelid and a.attnum = k.attnum
+      where n.nspname = 'public' and c.contype in ('p', 'u')
+      group by t.relname, c.conname, c.contype
+      order by 1, 2`;
+        return { specialOpclasses, hiddenConstraints: hidden.map((row) => row.table), keys };
     }
     finally {
         await sql.end();
@@ -185,6 +206,80 @@ export function pull(databaseUrl) {
         rmSync(dir, { recursive: true, force: true });
     }
 }
+/**
+ * pull reads keys from information_schema.constraint_column_usage, which Postgres fills only for tables
+ * the role owns, so as an app's reader it finds none. Adds each key its snapshot lacks, as pull records
+ * it for an owner; returns those keys for writeKeys.
+ */
+function addKeys(snapshot, keys) {
+    const tables = structuredClone(snapshot.tables);
+    const added = [];
+    for (const key of keys) {
+        const table = tables[`public.${key.table}`];
+        if (table === undefined)
+            throw new Error(`drizzle-kit pull didn't read ${key.table}, which has key ${key.name}.`);
+        const column = keyColumn(key);
+        if (key.kind === "u") {
+            if (key.name in table.uniqueConstraints)
+                continue;
+            table.uniqueConstraints[key.name] = { name: key.name, columns: key.columns, nullsNotDistinct: false };
+        }
+        else if (column === null) {
+            if (key.name in table.compositePrimaryKeys)
+                continue;
+            table.compositePrimaryKeys[key.name] = { name: key.name, columns: key.columns };
+        }
+        else {
+            const pulled = pulledColumn.parse(table.columns[column]);
+            if (pulled.primaryKey)
+                continue;
+            table.columns[column] = { ...pulled, primaryKey: true };
+        }
+        added.push(key);
+    }
+    return { snapshot: { ...snapshot, tables }, added };
+}
+/** A primary key's one column, which pull puts on the column itself; null for a composite key. */
+function keyColumn(key) {
+    const [column, ...rest] = key.columns;
+    return key.kind === "p" && column !== undefined && rest.length === 0 ? column : null;
+}
+/** A pulled table with the keys addKeys added to its snapshot, written as pull writes them. */
+function writeKeys(declaration, added) {
+    const keys = added.filter((key) => key.table === declaration.dbName);
+    if (declaration.kind !== "pgTable" || keys.length === 0)
+        return declaration;
+    const lines = declaration.text.split("\n");
+    const entries = [];
+    for (const key of keys) {
+        const column = keyColumn(key);
+        const columns = key.columns.map((name) => `table.${name}`).join(", ");
+        if (key.kind === "u") {
+            entries.push(`\tunique("${key.name}").on(${columns}),`);
+        }
+        else if (column === null) {
+            entries.push(`\tprimaryKey({ columns: [${columns}], name: "${key.name}"}),`);
+        }
+        else {
+            const at = lines.findIndex((line) => line.startsWith(`\t${column}: `) && line.endsWith(","));
+            const line = lines[at];
+            if (line === undefined)
+                throw new Error(`drizzle-kit pull wrote ${declaration.dbName}.${column} in a shape baseline can't read:\n${declaration.text}`);
+            lines[at] = `${line.slice(0, -1)}.primaryKey(),`;
+        }
+    }
+    let text = lines.join("\n");
+    if (entries.length > 0) {
+        const config = entries.join("\n");
+        if (text.endsWith("\n]);"))
+            text = `${text.slice(0, -"\n]);".length)}\n${config}\n]);`;
+        else if (text.endsWith("\n});"))
+            text = `${text.slice(0, -");".length)}, (table) => [\n${config}\n]);`;
+        else
+            throw new Error(`drizzle-kit pull wrote ${declaration.dbName} in a shape baseline can't read:\n${declaration.text}`);
+    }
+    return { ...declaration, text };
+}
 function readDeclaration(text) {
     const match = DECLARATION.exec(text);
     if (match === null)
@@ -243,7 +338,8 @@ function importedNames(source) {
         throw new Error(`drizzle-kit pull wrote no pg-core import baseline can read:\n${source}`);
     return z.string().parse(match[1]).split(",").map((name) => name.trim());
 }
-const uses = (text, name, after) => new RegExp(`\\b${name}${after}`).test(text);
+// Not after a dot: a column's `.primaryKey()` imports nothing.
+const uses = (text, name, after) => new RegExp(`(?<![.\\w])${name}${after}`).test(text);
 /**
  * One pulled `pgTable` as a db/schema file: an `entity()` (which declares its
  * standard columns itself) when it fits one, else the table as pulled.
@@ -264,7 +360,7 @@ function tableFile(table, live, asEntity, context) {
         if (!body.includes(ACCESS))
             throw new Error(`drizzle-kit pull wrote ${table.dbName} in a shape baseline can't read:\n${table.text}`);
     }
-    const pgCore = [...context.pgCore, "customType"].filter((name) => uses(body, name, "[<(]"));
+    const pgCore = [...new Set([...context.pgCore, "customType", "primaryKey", "unique"])].filter((name) => uses(body, name, "[<(]"));
     const referenced = new Set(Object.values(live.foreignKeys).map((key) => key.tableTo));
     const others = context.tables.filter((other) => other !== table && referenced.has(other.dbName));
     const types = new Set(Object.values(live.columns).map((column) => column.type));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trylight/app",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "The Light SDK every v2 org app depends on: entities (Drizzle tables with a typed client), sign-in, contracts and in-app chat.",
   "license": "UNLICENSED",
   "type": "module",