@trypattern/sdk 0.1.23 → 0.1.25

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.
+Rows that already exist (the live site has rows) need a value for a new required column, or for a
+column that becomes required: give it one in schema.ts with defaults: { colour: 'white' } on the
+table, or make it .nullable(). Without one this writes nothing and says which columns need it.`,
         run: migration,
         takesArgument: true
     },
@@ -1295,6 +1299,16 @@ async function migration(name) {
         '--name',
         name
     ]);
+    const unstarted = code === 0 ? startNewColumns(name) : [];
+    if (unstarted.length > 0) {
+        const named = unstarted.map(({ table, column }) => `${camelCase(table)}.${camelCase(column)}`);
+        const example = camelCase(unstarted[0]?.column ?? '');
+        return {
+            code: 1,
+            data: { error: 'no starting value', columns: named },
+            text: `✗ app migration ${name}: ${named.join(', ')} ${named.length === 1 ? 'is' : 'are'} required, and rows that already exist (the live site has rows) need a value. Nothing was written.\n  next  say what existing rows start with in schema.ts, on that table: defaults: { ${example}: … }, or make the column .nullable(). Then run app migration ${name} again.`
+        };
+    }
     const warning = code === 0 ? ownerBackfillWarning(name) : undefined;
     return {
         code,
@@ -1302,11 +1316,77 @@ async function migration(name) {
         text: `${code === 0 ? '✓' : '✗'} app migration ${name}\n\n${indent(output.trimEnd())}${warning === undefined ? '' : `\n\n! ${warning}`}`
     };
 }
-function ownerBackfillWarning(name) {
-    const file = readdirSync(MIGRATIONS_DIR)
+function camelCase(name) {
+    return name.replaceAll(/_([a-z0-9])/g, (_match, letter) => letter.toUpperCase());
+}
+function journalEntries() {
+    const journal = join(MIGRATIONS_DIR, 'meta', '_journal.json');
+    if (!existsSync(journal))
+        return undefined;
+    const raw = JSON.parse(readText(journal));
+    const entries = z
+        .object({
+        entries: z.array(z.object({ idx: z.number(), tag: z.string() }))
+    })
+        .parse(raw).entries;
+    return { journal, raw, entries };
+}
+function snapshotPath(idx) {
+    return join(MIGRATIONS_DIR, 'meta', `${String(idx).padStart(4, '0')}_snapshot.json`);
+}
+function forgetMigration(file) {
+    rmSync(join(MIGRATIONS_DIR, file), { force: true });
+    const found = journalEntries();
+    const entry = found?.entries.find((item) => `${item.tag}.sql` === file);
+    if (found === undefined || entry === undefined)
+        return;
+    rmSync(snapshotPath(entry.idx), { force: true });
+    writeFileSync(found.journal, `${JSON.stringify({
+        ...Object(found.raw),
+        entries: Reflect.get(Object(found.raw), 'entries').filter((item) => Reflect.get(Object(item), 'tag') !== entry.tag)
+    }, null, 2)}\n`);
+}
+function newestMigration(name) {
+    return readdirSync(MIGRATIONS_DIR)
         .filter((entry) => entry.endsWith(`_${name}.sql`))
         .sort()
         .at(-1);
+}
+function previousTables(file) {
+    const entries = journalEntries()?.entries ?? [];
+    const at = entries.findIndex((entry) => `${entry.tag}.sql` === file);
+    const before = at > 0 ? entries[at - 1] : undefined;
+    if (before === undefined)
+        return {};
+    const snapshot = snapshotPath(before.idx);
+    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, unstarted } = withStartingValues(readText(path), tables);
+    if (unstarted.length > 0)
+        forgetMigration(file);
+    else
+        writeFileSync(path, sql);
+    return unstarted;
+}
+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,13 @@
+type Columns = Readonly<Record<string, {
+    notNull: boolean;
+}>>;
+export type PreviousTables = Readonly<Record<string, Columns>>;
+export type Unstarted = {
+    table: string;
+    column: string;
+};
+export declare function withStartingValues(sql: string, previous: PreviousTables): {
+    sql: string;
+    unstarted: Unstarted[];
+};
+export {};

package/dist/cli/startingValues.js

@@ -0,0 +1,48 @@
+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 COLUMN = /^\s*`(\w+)` (?:text|integer|real)(.*)$/;
+const STARTS_AS = / DEFAULT ('(?:[^']|'')*'|[-\w.]+)/;
+function quoted(names) {
+    return names.split(',').map((name) => name.trim().replaceAll('"', ''));
+}
+function startsOf(body) {
+    const starts = new Map();
+    for (const line of body.split('\n')) {
+        const match = COLUMN.exec(line);
+        const rest = match?.[2] ?? '';
+        if (match?.[1] === undefined || !rest.includes('NOT NULL'))
+            continue;
+        if (rest.includes('PRIMARY KEY'))
+            continue;
+        starts.set(match[1], STARTS_AS.exec(rest)?.[1] ?? null);
+    }
+    return starts;
+}
+export function withStartingValues(sql, previous) {
+    const unstarted = [
+        ...Array.from(sql.matchAll(ADDED), ([, table = '', column = '']) => ({
+            table,
+            column
+        }))
+    ];
+    const rebuilt = sql.replaceAll(REBUILT, (whole, table, body, between, into, from) => {
+        const old = previous[table];
+        if (old === undefined)
+            return whole;
+        const starts = startsOf(body);
+        const selected = quoted(from).map((column) => {
+            const before = old[column];
+            if (!starts.has(column) || before?.notNull === true) {
+                return `"${column}"`;
+            }
+            const start = starts.get(column) ?? null;
+            if (start === null) {
+                unstarted.push({ table, column });
+                return `"${column}"`;
+            }
+            return before === undefined ? start : `coalesce("${column}", ${start})`;
+        });
+        return `CREATE TABLE \`__new_${table}\` (${body}\n);${between}INSERT INTO \`__new_${table}\`(${into}) SELECT ${selected.join(', ')} FROM \`${table}\`;`;
+    });
+    return { sql: rebuilt, unstarted };
+}

package/dist/server/tables.js

@@ -12,7 +12,7 @@ function typesOf(schema) {
         return [type];
     return Array.isArray(type) ? type : [];
 }
-function sqlColumn(key, schema) {
+function sqlColumn(key, schema, start) {
     const types = typesOf(schema);
     const name = snakeCase(key);
     const column = types.includes('boolean')
@@ -22,7 +22,8 @@ function sqlColumn(key, schema) {
             : types.includes('number')
                 ? real(name)
                 : text(name);
-    return types.includes('null') ? column : column.notNull();
+    const started = start === undefined ? column : column.default(start);
+    return types.includes('null') ? started : started.notNull();
 }
 function uniqueIndexName(table, columns) {
     return [table.name, ...columns, 'unique'].map(snakeCase).join('_');
@@ -30,7 +31,7 @@ function uniqueIndexName(table, columns) {
 export function sqlTable(table) {
     const columns = Object.fromEntries(Object.entries(table.columns).map(([key, schema]) => [
         key,
-        sqlColumn(key, schema)
+        sqlColumn(key, schema, table.defaults[key])
     ]));
     return sqliteTable(snakeCase(table.name), {
         id: text('id').primaryKey(),

package/dist/table.d.ts

@@ -17,6 +17,7 @@ export type TableDefinition = {
     readonly owned?: boolean;
     readonly public?: readonly string[];
     readonly unique?: readonly (readonly string[])[];
+    readonly defaults?: Readonly<Record<string, Value>>;
 };
 type OwnerColumn<Owned> = [Owned] extends [true] ? {
     ownerId: z.ZodString;
@@ -29,6 +30,7 @@ export type Table = {
     readonly owned: boolean;
     readonly public: readonly string[];
     readonly unique: readonly (readonly string[])[];
+    readonly defaults: Readonly<Record<string, Value>>;
     readonly fields: z.ZodObject<Columns>;
     readonly incoming: z.ZodObject<{
         id: z.ZodString;
@@ -49,6 +51,7 @@ export type TableOf<Name extends string, Definition extends TableDefinition> = {
     readonly owned: Definition['owned'] extends true ? true : false;
     readonly public: readonly PublicColumn<Definition>[];
     readonly unique: readonly (readonly string[])[];
+    readonly defaults: Readonly<Record<string, Value>>;
     readonly fields: z.ZodObject<Definition['columns']>;
     readonly incoming: z.ZodObject<{
         id: z.ZodString;
@@ -96,6 +99,7 @@ type DraftTable = {
     readonly owned?: boolean;
     readonly public?: readonly string[];
     readonly unique?: readonly (readonly string[])[];
+    readonly defaults?: Readonly<Record<string, Value>>;
 };
 type StaticTypeError<Message extends string> = Message;
 type IsOwned<Definition> = Definition extends {
@@ -112,6 +116,11 @@ type ReadOf<Definition> = Definition extends {
 type ColumnOf<Definition> = Definition extends {
     readonly columns: infer C;
 } ? keyof C & string : never;
+type DefaultsOf<Definition> = Definition extends {
+    readonly columns: infer C extends Columns;
+} ? {
+    readonly [Key in keyof C]?: z.output<C[Key]>;
+} : never;
 type OwnerNeedsOwned = StaticTypeError<"'owner' needs owned: true on this table, so every row records who made it">;
 type CreateIsNeverOwner = StaticTypeError<"create can't be 'owner': nobody owns a row before it exists. Use 'signedIn' and the person who creates it becomes its owner">;
 type OwnedNeedsSignedInCreate = StaticTypeError<"An owned table can't let anyone create rows: a signed-out visitor has no account to own the row. Use 'signedIn'">;
@@ -132,7 +141,7 @@ type CheckedColumns<C> = {
     [Key in keyof C]: Key extends 'ownerId' ? OwnerIdIsPattern : C[Key];
 };
 type CheckedTable<Definition> = {
-    [Key in keyof Definition]: Key extends 'columns' ? CheckedColumns<SameOnTheWire<Definition[Key] & z.ZodRawShape>> : Key extends 'access' ? CheckedAccess<Definition, Definition[Key]> : Key extends 'writes' ? HasUnique<Definition> extends true ? Definition[Key] extends 'confirmed' ? Definition[Key] : UniqueNeedsConfirmed : Definition[Key] : Key extends 'public' ? ReadOf<Definition> extends 'anyone' ? PublicNeedsPrivateRead : Definition[Key] & readonly (ColumnOf<Definition> | 'createdAt')[] : Key extends 'unique' ? Definition[Key] & readonly (readonly ColumnOf<Definition>[])[] : Definition[Key];
+    [Key in keyof Definition]: Key extends 'columns' ? CheckedColumns<SameOnTheWire<Definition[Key] & z.ZodRawShape>> : Key extends 'access' ? CheckedAccess<Definition, Definition[Key]> : Key extends 'writes' ? HasUnique<Definition> extends true ? Definition[Key] extends 'confirmed' ? Definition[Key] : UniqueNeedsConfirmed : Definition[Key] : Key extends 'public' ? ReadOf<Definition> extends 'anyone' ? PublicNeedsPrivateRead : Definition[Key] & readonly (ColumnOf<Definition> | 'createdAt')[] : Key extends 'unique' ? Definition[Key] & readonly (readonly ColumnOf<Definition>[])[] : Key extends 'defaults' ? Definition[Key] & DefaultsOf<Definition> : Definition[Key];
 } & Missing<Definition, 'access', AccessIsRequired> & Missing<Definition, 'writes', WritesIsRequired>;
 export declare function defineTables<const Definitions extends Record<string, DraftTable> = Record<never, never>>(definitions: {
     [Key in keyof Definitions]: CheckedTable<Definitions[Key]>;

package/dist/table.js

@@ -28,6 +28,15 @@ function problemIn(name, definition) {
     if (unknown !== undefined) {
         return `Table "${name}" names "${unknown}", which is not one of its columns`;
     }
+    for (const [column, value] of Object.entries(definition.defaults ?? {})) {
+        const schema = columns[column];
+        if (schema === undefined) {
+            return `Table "${name}" has a default for "${column}", which is not one of its columns`;
+        }
+        if (!schema.safeParse(value).success) {
+            return `Table "${name}": the default for "${column}" isn't a valid ${column}`;
+        }
+    }
     if ((definition.unique ?? []).length > 0 &&
         definition.writes !== 'confirmed') {
         return `Table "${name}" has a unique constraint, so writes must be 'confirmed'`;
@@ -65,6 +74,7 @@ function table(name, definition, isPatterns = false) {
         owned,
         public: publicColumns,
         unique: definition.unique ?? [],
+        defaults: definition.defaults ?? {},
         fields: z.object(columns),
         incoming: z.object({ id: z.string(), ...columns }),
         row: z.object({

package/package.json

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