@trypattern/sdk 0.1.24 → 0.1.25

package/dist/cli/app.js

@@ -217,9 +217,9 @@ changing seed.ts or starter/. Works while the dev server runs; reload the page t
 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.
-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.`,
+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
     },
@@ -1299,38 +1299,66 @@ async function migration(name) {
         '--name',
         name
     ]);
-    const notes = code === 0 ? startNewColumns(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,
-        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}`}`
+        data: { output: output.trimEnd(), ...(warning && { warning }) },
+        text: `${code === 0 ? '✓' : '✗'} app migration ${name}\n\n${indent(output.trimEnd())}${warning === undefined ? '' : `\n\n! ${warning}`}`
     };
 }
-function newestMigration(name) {
-    return readdirSync(MIGRATIONS_DIR)
-        .filter((entry) => entry.endsWith(`_${name}.sql`))
-        .sort()
-        .at(-1);
+function camelCase(name) {
+    return name.replaceAll(/_([a-z0-9])/g, (_match, letter) => letter.toUpperCase());
 }
-function previousTables(file) {
+function journalEntries() {
     const journal = join(MIGRATIONS_DIR, 'meta', '_journal.json');
     if (!existsSync(journal))
-        return {};
+        return undefined;
+    const raw = JSON.parse(readText(journal));
     const entries = z
         .object({
         entries: z.array(z.object({ idx: z.number(), tag: z.string() }))
     })
-        .parse(JSON.parse(readText(journal))).entries;
+        .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 = join(MIGRATIONS_DIR, 'meta', `${String(before.idx).padStart(4, '0')}_snapshot.json`);
+    const snapshot = snapshotPath(before.idx);
     if (!existsSync(snapshot))
         return {};
     return z
@@ -1350,9 +1378,12 @@ function startNewColumns(name) {
         table,
         columns
     ]));
-    const { sql, notes } = withStartingValues(readText(path), tables);
-    writeFileSync(path, sql);
-    return notes.map((note) => `${file}: ${note}`);
+    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);

package/dist/cli/startingValues.d.ts

@@ -2,8 +2,12 @@ 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;
-    notes: string[];
+    unstarted: Unstarted[];
 };
 export {};

package/dist/cli/startingValues.js

@@ -1,58 +1,48 @@
-const ADDED = /^ALTER TABLE `(\w+)` ADD `(\w+)` (text|integer|real) NOT NULL;/gm;
+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'
-};
+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 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 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 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 starts = startsOf(body);
         const selected = quoted(from).map((column) => {
-            const type = types.get(column);
             const before = old[column];
-            if (type === undefined)
+            if (!starts.has(column) || before?.notNull === true) {
                 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})`;
+            const start = starts.get(column) ?? null;
+            if (start === null) {
+                unstarted.push({ table, column });
+                return `"${column}"`;
             }
-            return `"${column}"`;
+            return before === undefined ? start : `coalesce("${column}", ${start})`;
         });
-        return `CREATE TABLE \`__new_${table}\` (${lines.join('\n')}\n);${between}INSERT INTO \`__new_${table}\`(${into}) SELECT ${selected.join(', ')} FROM \`${table}\`;`;
+        return `CREATE TABLE \`__new_${table}\` (${body}\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.`)
-    };
+    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.24",
+  "version": "0.1.25",
   "type": "module",
   "files": [
     "dist",