@trypattern/sdk 0.1.23 → 0.1.24

package/dist/cli/app.js

@@ -22,6 +22,7 @@ import { readStarter, starterContentOf, withStarter } from "./starter.js";
 import { addLiveMedia, login, publish, pull, restore, versions as listVersions } from "./publishing.js";
 import { CHANGE_SET_ROWS } from "../publishWire.js";
 import { DATA_USAGE, data } from "./data.js";
+import { withStartingValues } from "./startingValues.js";
 import { toolBin } from "./tools.js";
 import { isNewer, latestPattern, newerPattern, updateNote } from "./updates.js";
 function dependsOnPattern(directory) {
@@ -215,7 +216,10 @@ changing seed.ts or starter/. Works while the dev server runs; reload the page t
         details: `app migration add_due_dates
 Compares the tables in schema.ts (plus Pattern's users, sessions and settings tables) with server/migrations and writes the
 SQL that moves the database from one to the other, named <number>_<name>.sql. app start applies new
-migrations to the local database. Prints "No schema changes" when the migrations already match.`,
+migrations to the local database. Prints "No schema changes" when the migrations already match.
+A new required column starts as empty, 0 or false on rows that already exist (the live site has rows),
+and a column made required fills its empty rows the same way; each is noted. To start them on a
+real value, add an UPDATE after it in the migration file.`,
         run: migration,
         takesArgument: true
     },
@@ -1295,18 +1299,63 @@ async function migration(name) {
         '--name',
         name
     ]);
+    const notes = code === 0 ? startNewColumns(name) : [];
     const warning = code === 0 ? ownerBackfillWarning(name) : undefined;
     return {
         code,
-        data: { output: output.trimEnd(), ...(warning && { warning }) },
-        text: `${code === 0 ? '✓' : '✗'} app migration ${name}\n\n${indent(output.trimEnd())}${warning === undefined ? '' : `\n\n! ${warning}`}`
+        data: {
+            output: output.trimEnd(),
+            startingValues: notes,
+            ...(warning && { warning })
+        },
+        text: `${code === 0 ? '✓' : '✗'} app migration ${name}\n\n${indent(output.trimEnd())}${notes.map((note) => `\n  note  ${note}`).join('')}${warning === undefined ? '' : `\n\n! ${warning}`}`
     };
 }
-function ownerBackfillWarning(name) {
-    const file = readdirSync(MIGRATIONS_DIR)
+function newestMigration(name) {
+    return readdirSync(MIGRATIONS_DIR)
         .filter((entry) => entry.endsWith(`_${name}.sql`))
         .sort()
         .at(-1);
+}
+function previousTables(file) {
+    const journal = join(MIGRATIONS_DIR, 'meta', '_journal.json');
+    if (!existsSync(journal))
+        return {};
+    const entries = z
+        .object({
+        entries: z.array(z.object({ idx: z.number(), tag: z.string() }))
+    })
+        .parse(JSON.parse(readText(journal))).entries;
+    const at = entries.findIndex((entry) => `${entry.tag}.sql` === file);
+    const before = at > 0 ? entries[at - 1] : undefined;
+    if (before === undefined)
+        return {};
+    const snapshot = join(MIGRATIONS_DIR, 'meta', `${String(before.idx).padStart(4, '0')}_snapshot.json`);
+    if (!existsSync(snapshot))
+        return {};
+    return z
+        .object({
+        tables: z.record(z.string(), z.object({
+            columns: z.record(z.string(), z.object({ notNull: z.boolean() }))
+        }))
+    })
+        .parse(JSON.parse(readText(snapshot))).tables;
+}
+function startNewColumns(name) {
+    const file = newestMigration(name);
+    if (file === undefined)
+        return [];
+    const path = join(MIGRATIONS_DIR, file);
+    const tables = Object.fromEntries(Object.entries(previousTables(file)).map(([table, { columns }]) => [
+        table,
+        columns
+    ]));
+    const { sql, notes } = withStartingValues(readText(path), tables);
+    writeFileSync(path, sql);
+    return notes.map((note) => `${file}: ${note}`);
+}
+function ownerBackfillWarning(name) {
+    const file = newestMigration(name);
     if (file === undefined)
         return undefined;
     const sql = readFileSync(join(MIGRATIONS_DIR, file), 'utf8');

package/dist/cli/startingValues.d.ts

@@ -0,0 +1,9 @@
+type Columns = Readonly<Record<string, {
+    notNull: boolean;
+}>>;
+export type PreviousTables = Readonly<Record<string, Columns>>;
+export declare function withStartingValues(sql: string, previous: PreviousTables): {
+    sql: string;
+    notes: string[];
+};
+export {};

package/dist/cli/startingValues.js

@@ -0,0 +1,58 @@
+const ADDED = /^ALTER TABLE `(\w+)` ADD `(\w+)` (text|integer|real) NOT NULL;/gm;
+const REBUILT = /CREATE TABLE `__new_(\w+)` \(([^;]*?)\n\);(\n(?:--> statement-breakpoint\n)?\n?)INSERT INTO `__new_\1`\(([^)]*)\) SELECT ([^;]*) FROM `\1`;/g;
+const REQUIRED = /^(\s*`(\w+)` (text|integer|real)) NOT NULL(,?)$/;
+const STARTING_VALUES = {
+    text: "''",
+    integer: '0',
+    real: '0'
+};
+const SPOKEN = {
+    text: 'empty',
+    integer: '0 (or "no")',
+    real: '0'
+};
+function quoted(names) {
+    return names.split(',').map((name) => name.trim().replaceAll('"', ''));
+}
+export function withStartingValues(sql, previous) {
+    const started = [];
+    const added = sql.replaceAll(ADDED, (_line, table, column, type) => {
+        started.push({ table, column, type });
+        return `ALTER TABLE \`${table}\` ADD \`${column}\` ${type} NOT NULL DEFAULT ${STARTING_VALUES[type] ?? "''"};`;
+    });
+    const rebuilt = added.replaceAll(REBUILT, (whole, table, body, between, into, from) => {
+        const old = previous[table];
+        if (old === undefined)
+            return whole;
+        const types = new Map();
+        const lines = body.split('\n').map((line) => {
+            const match = REQUIRED.exec(line);
+            if (match === null || line.includes('PRIMARY KEY'))
+                return line;
+            const [, start = '', column = '', type = '', comma = ''] = match;
+            types.set(column, type);
+            return `${start} NOT NULL DEFAULT ${STARTING_VALUES[type] ?? "''"}${comma}`;
+        });
+        const selected = quoted(from).map((column) => {
+            const type = types.get(column);
+            const before = old[column];
+            if (type === undefined)
+                return `"${column}"`;
+            const value = STARTING_VALUES[type] ?? "''";
+            if (before === undefined) {
+                started.push({ table, column, type });
+                return value;
+            }
+            if (!before.notNull) {
+                started.push({ table, column, type });
+                return `coalesce("${column}", ${value})`;
+            }
+            return `"${column}"`;
+        });
+        return `CREATE TABLE \`__new_${table}\` (${lines.join('\n')}\n);${between}INSERT INTO \`__new_${table}\`(${into}) SELECT ${selected.join(', ')} FROM \`${table}\`;`;
+    });
+    return {
+        sql: rebuilt,
+        notes: started.map(({ table, column, type }) => `${table}.${column} starts as ${SPOKEN[type] ?? 'empty'} on rows that already exist. To start them on a real value, add UPDATE \`${table}\` SET \`${column}\` = … after it in the migration.`)
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trypattern/sdk",
-  "version": "0.1.23",
+  "version": "0.1.24",
   "type": "module",
   "files": [
     "dist",