@trypattern/sdk 0.1.22 → 0.1.24

package/dist/cli/app.js

@@ -22,7 +22,9 @@ 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) {
     try {
         const manifest = JSON.parse(readFileSync(join(directory, 'package.json'), 'utf8'));
@@ -80,6 +82,7 @@ const CONTACT_SHEET = join(SCREENSHOTS_DIR, 'contact-sheet.png');
 const SCREENSHOT_WORKER = join(SDK_SOURCE, 'cli', `screenshot${SDK_EXTENSION}`);
 const VISUAL_URL_ENV = 'PATTERN_VISUAL_URL';
 const GLOBAL_FLAGS = ['--json', '--help', '-h'];
+const NUDGED_COMMANDS = new Set(['start', 'check', 'publish', 'data']);
 const VALUE_FLAGS = new Set([
     '--commands',
     '--name',
@@ -213,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
     },
@@ -373,6 +379,15 @@ collected changes. Up to ${CHANGE_SET_ROWS} changes per request. For this comput
         argumentCount: 3,
         flags: ['--row', '--set', '--file', '--asked']
     },
+    update: {
+        summary: 'Bring this project to the newest Pattern',
+        details: `Installs the newest @trypattern/sdk from npm into this project (pnpm add, exact version).
+start, check, publish and data say when a newer Pattern is out. The live site keeps the old one until
+the next app publish, so run app check, then publish it (straight away when nothing else is in
+progress). New Pattern features on the live site, such as the owner approving app data changes,
+need that publish.`,
+        run: update
+    },
     versions: {
         summary: 'List the versions that went live, newest first',
         details: 'Each version with its number, whether it went live, when, and who published it. app restore <number> puts one back.',
@@ -1284,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');
@@ -1492,6 +1552,43 @@ function installShim() {
         path: SHIM_PATH
     };
 }
+async function update() {
+    const current = sdkVersion();
+    const latest = await latestPattern(true);
+    if (latest === undefined) {
+        return {
+            code: 1,
+            data: { current, error: 'npm did not answer' },
+            text: '✗ Couldn’t reach npm to find the newest Pattern. Check the internet connection and try again.'
+        };
+    }
+    if (!isNewer(latest, current)) {
+        return {
+            code: 0,
+            data: { current, latest, updated: false },
+            text: `✓ Pattern is up to date (${current})`
+        };
+    }
+    say(`Updating Pattern ${current} → ${latest}`);
+    const installed = await capture('pnpm', ['add', `@trypattern/sdk@${latest}`]);
+    if (installed.code !== 0) {
+        return {
+            code: 1,
+            data: {
+                current,
+                latest,
+                error: 'pnpm add failed',
+                output: installed.output
+            },
+            text: `✗ pnpm couldn’t install Pattern ${latest}:\n${installed.output.trim().split('\n').slice(-LOG_TAIL_LINES).join('\n')}`
+        };
+    }
+    return {
+        code: 0,
+        data: { current, latest, updated: true },
+        text: `✓ Updated Pattern ${current} → ${latest}\n  next  run app check, then app publish --message 'Updated Pattern' (straight away if nothing else is in progress) so the live site gets it`
+    };
+}
 async function setup() {
     const pins = readPins();
     const haveNode = process.versions.node;
@@ -1635,6 +1732,16 @@ async function main(argv) {
     }
     else {
         outcome = await command.run(positional[1], options, positional.slice(1));
+        if (NUDGED_COMMANDS.has(name)) {
+            const latest = await newerPattern(sdkVersion());
+            if (latest !== undefined) {
+                outcome = {
+                    ...outcome,
+                    data: { ...outcome.data, newerPattern: latest },
+                    text: `${outcome.text}\n${updateNote(latest, sdkVersion())}`
+                };
+            }
+        }
     }
     if (jsonMode) {
         const payload = {

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/dist/cli/updates.d.ts

@@ -0,0 +1,4 @@
+export declare function isNewer(candidate: string, current: string): boolean;
+export declare function latestPattern(fresh?: boolean): Promise<string | undefined>;
+export declare function newerPattern(current: string): Promise<string | undefined>;
+export declare function updateNote(latest: string, current: string): string;

package/dist/cli/updates.js

@@ -0,0 +1,68 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { z } from 'zod';
+const LATEST_URL = 'https://registry.npmjs.org/@trypattern/sdk/latest';
+const CACHE_FILE = join(homedir(), '.config', 'pattern', 'latest-sdk.json');
+const CHECK_MS = 6 * 3_600_000;
+const TIMEOUT_MS = 1500;
+const cached = z.object({ version: z.string(), checkedAt: z.number() });
+const published = z.object({ version: z.string() });
+function partsOf(version) {
+    return (version
+        .split('-')[0]
+        ?.split('.')
+        .map((part) => Number.parseInt(part, 10) || 0) ?? [0]);
+}
+export function isNewer(candidate, current) {
+    const next = partsOf(candidate);
+    const now = partsOf(current);
+    for (let index = 0; index < Math.max(next.length, now.length); index += 1) {
+        const difference = (next[index] ?? 0) - (now[index] ?? 0);
+        if (difference !== 0)
+            return difference > 0;
+    }
+    return false;
+}
+function readCache() {
+    if (!existsSync(CACHE_FILE))
+        return undefined;
+    try {
+        const parsed = cached.safeParse(JSON.parse(readFileSync(CACHE_FILE, 'utf8')));
+        return parsed.success ? parsed.data : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function latestPattern(fresh = false) {
+    const remembered = readCache();
+    if (!fresh &&
+        remembered !== undefined &&
+        Date.now() - remembered.checkedAt < CHECK_MS) {
+        return remembered.version;
+    }
+    try {
+        const response = await fetch(LATEST_URL, {
+            signal: AbortSignal.timeout(TIMEOUT_MS)
+        });
+        const body = published.safeParse(await response.json());
+        if (!response.ok || !body.success)
+            return remembered?.version;
+        mkdirSync(dirname(CACHE_FILE), { recursive: true });
+        writeFileSync(CACHE_FILE, JSON.stringify({ version: body.data.version, checkedAt: Date.now() }));
+        return body.data.version;
+    }
+    catch {
+        return remembered?.version;
+    }
+}
+export async function newerPattern(current) {
+    if (process.env['PATTERN_NO_UPDATE_CHECK'] !== undefined)
+        return undefined;
+    const latest = await latestPattern();
+    return latest !== undefined && isNewer(latest, current) ? latest : undefined;
+}
+export function updateNote(latest, current) {
+    return `  update  Pattern ${latest} is out (this project has ${current}). Run app update now, then app check. Publish it straight away if nothing else is in progress, otherwise with the next publish, so the live site gets it too. Tell the owner in a few words.`;
+}

package/package.json

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