@trypattern/sdk 0.1.0 → 0.1.2

package/dist/cli/app.js

@@ -14,6 +14,7 @@ import { delimiter, dirname, extname, join, relative, resolve } from 'node:path'
 import { pathToFileURL } from 'node:url';
 import { createHash } from 'node:crypto';
 import { resetLocalDatabase } from "../vite/localWorker.js";
+import { login, publish, pull, restore, versions as listVersions } from "./publishing.js";
 import { toolBin } from "./tools.js";
 function dependsOnPattern(directory) {
     try {
@@ -36,15 +37,14 @@ function findRoot() {
     let directory = process.cwd();
     while (!dependsOnPattern(directory)) {
         const parent = dirname(directory);
-        if (parent === directory) {
-            process.stderr.write('app: no Pattern project here. Run app inside a project that depends on @trypattern/sdk.\n');
-            process.exit(2);
-        }
+        if (parent === directory)
+            return undefined;
         directory = parent;
     }
     return directory;
 }
-const ROOT = findRoot();
+const FOUND_ROOT = findRoot();
+const ROOT = FOUND_ROOT ?? process.cwd();
 const SDK_SOURCE = resolve(import.meta.dirname, '..');
 const SDK_EXTENSION = extname(import.meta.filename);
 const FORMATTED_PATHS = [
@@ -182,7 +182,7 @@ Works while the dev server runs; reload the page to see the new rows.`,
     migration: {
         summary: 'Write a database migration for the tables in schema.ts',
         details: `app migration add_due_dates
-Compares the tables in schema.ts (plus Pattern's users and sessions tables) with server/migrations and writes the
+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.`,
         run: migration,
@@ -252,9 +252,52 @@ dev server (app check proves the production build has none). Sign out with app s
         })),
         takesArgument: true
     },
+    login: {
+        summary: 'Let this computer publish: approve it once in the browser',
+        details: `Opens onpattern.app in the browser with a short code (like FOX-7421) and prints the same
+code. The person checks the codes match and clicks Allow; run app login again and it finishes.
+The session lasts 30 days and lives in ~/.config/pattern/credentials.json. pull, publish, versions
+and restore sign in the same way when they need to, so this is rarely run on its own.`,
+        run: () => login(publishingIo()),
+        runsAnywhere: true
+    },
+    pull: {
+        summary: 'Download a site from onpattern.app and install it, ready for app start',
+        details: `app pull sundayparty
+Downloads the source of the site's latest live version into this folder when it is empty, or into
+./<name> otherwise, writes pattern.json, installs, and runs app setup. Never needs git; when the
+Command Line Tools are installed it also makes a first commit. Signs in first if needed (see app login).`,
+        run: (argument) => pull(publishingIo(), argument, process.cwd()),
+        takesArgument: true,
+        runsAnywhere: true
+    },
+    publish: {
+        summary: 'Build this app and put it live at <name>.onpattern.app',
+        details: `Builds (vite build), then uploads the build, server/migrations and the source (every file
+git would keep, never .dev.vars, .env, node_modules, dist or .dev) to onpattern.app, and waits
+until the new version answers at https://<name>.onpattern.app, printing each step. The database
+moves forward with any new migrations; nothing is ever deleted from it. If a step fails, the site
+keeps running the previous version and the error says why. Run app check first.
+--starter (Pattern's admins only) publishes this project as the starter every new site begins from.`,
+        run: (_argument, options) => publish(publishingIo(), ROOT, options.has('--starter')),
+        flags: ['--starter']
+    },
+    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.',
+        run: () => listVersions(publishingIo(), ROOT)
+    },
+    restore: {
+        summary: 'Put an earlier version back live (app restore <number>)',
+        details: `app restore 3
+Publishes version 3's build again as a new version. The database is not rolled back: it keeps
+every row and column added since, which version 3's code ignores.`,
+        run: (argument) => restore(publishingIo(), ROOT, argument),
+        takesArgument: true
+    },
     setup: {
-        summary: 'Verify Node/pnpm match the pins, pnpm install, install the global `app` shim',
-        details: `Idempotent. Fails if Node != .nvmrc or pnpm != package.json "packageManager".
+        summary: 'Verify Node/pnpm major versions, pnpm install, install the global `app` shim',
+        details: `Idempotent. Fails unless Node and pnpm have the major versions in .nvmrc and package.json "packageManager".
 Then runs \`pnpm install\` and installs ${SHIM_PATH}, a tiny shim that walks up from the
 current directory to the nearest project launcher (an executable ./app containing the line
 ${LAUNCHER_MARKER_LINE}) and runs it, so each project's CLI lives in its repo and the shim
@@ -270,6 +313,29 @@ existing ${SHIM_PATH} that was not installed by Pattern.`,
 };
 let jsonMode = false;
 let openBrowser = false;
+function sdkVersion() {
+    const manifest = JSON.parse(readText(resolve(SDK_SOURCE, '..', 'package.json')));
+    return String(Reflect.get(Object(manifest), 'version') ?? '');
+}
+function publishingIo() {
+    return {
+        say,
+        openUrl,
+        build,
+        sdkVersion: sdkVersion(),
+        run: (bin, args, cwd) => new Promise((done) => {
+            let output = '';
+            const child = spawn(bin, args, {
+                cwd,
+                stdio: ['ignore', 'pipe', 'pipe']
+            });
+            child.stdout.on('data', (chunk) => (output += chunk.toString()));
+            child.stderr.on('data', (chunk) => (output += chunk.toString()));
+            child.on('error', (err) => done({ code: 127, output: `failed to run ${bin}: ${err.message}` }));
+            child.on('close', (code) => done({ code: code ?? 1, output }));
+        })
+    };
+}
 function progressStream() {
     return jsonMode ? process.stderr : process.stdout;
 }
@@ -1059,10 +1125,11 @@ async function writeDatabaseSchema() {
     writeFileSync(file, [
         `import { sqlTable } from ${JSON.stringify(join(server, `tables${SDK_EXTENSION}`))}`,
         `import { sessions } from ${JSON.stringify(join(server, `sessions${SDK_EXTENSION}`))}`,
+        `import { settings } from ${JSON.stringify(join(server, `settings${SDK_EXTENSION}`))}`,
         `import { users } from ${JSON.stringify(join(server, `users${SDK_EXTENSION}`))}`,
         `import { tables } from ${JSON.stringify(join(ROOT, 'schema.ts'))}`,
         '',
-        'export { sessions, users }',
+        'export { sessions, settings, users }',
         ...keys.map((key) => `export const ${key} = sqlTable(tables[${JSON.stringify(key)}])`),
         ''
     ].join('\n'));
@@ -1147,6 +1214,9 @@ async function build() {
             : `✗ Build failed\n\n${indent(output.trimEnd())}`
     };
 }
+function majorOf(version) {
+    return version.split('.')[0] ?? '';
+}
 function readPins() {
     const node = readText(join(ROOT, '.nvmrc')).trim().replace(/^v/, '');
     const pkg = JSON.parse(readText(join(ROOT, 'package.json')));
@@ -1186,11 +1256,11 @@ async function setup() {
     });
     const havePnpm = (pnpmVersion.stdout ?? '').trim();
     const problems = [];
-    if (haveNode !== pins.node) {
-        problems.push(`Node ${haveNode} does not match .nvmrc (${pins.node})\n  fix  nvm install && nvm use`);
+    if (majorOf(haveNode) !== majorOf(pins.node)) {
+        problems.push(`Node ${haveNode} is not Node ${majorOf(pins.node)} (.nvmrc says ${pins.node})\n  fix  pnpm env use --global ${majorOf(pins.node)}`);
     }
-    if (havePnpm !== pins.pnpm) {
-        problems.push(`pnpm ${havePnpm || '(not found)'} does not match package.json packageManager (${pins.pnpm})\n  fix  corepack enable pnpm`);
+    if (majorOf(havePnpm) !== majorOf(pins.pnpm)) {
+        problems.push(`pnpm ${havePnpm || '(not found)'} is not pnpm ${majorOf(pins.pnpm)} (package.json packageManager says ${pins.pnpm})\n  fix  curl -fsSL https://get.pnpm.io/install.sh | sh -`);
     }
     const versions = { node: haveNode, pnpm: havePnpm, expected: pins };
     if (problems.length > 0) {
@@ -1200,7 +1270,7 @@ async function setup() {
             text: problems.map((p) => `✗ ${p}`).join('\n')
         };
     }
-    say(`✓ Node ${haveNode} and pnpm ${havePnpm} match the pins`);
+    say(`✓ Node ${haveNode} and pnpm ${havePnpm} match the pinned major versions`);
     const install = await capture('pnpm', ['install']);
     if (install.code !== 0) {
         return {
@@ -1301,6 +1371,13 @@ async function main(argv) {
             text: `app: ${problem}\n${usage.text}`
         };
     }
+    else if (FOUND_ROOT === undefined && command.runsAnywhere !== true) {
+        outcome = {
+            code: 2,
+            data: { error: 'no Pattern project here' },
+            text: 'app: no Pattern project here. Run app inside a project that depends on @trypattern/sdk, or app pull <name> to download one.'
+        };
+    }
     else if (wantsHelp) {
         outcome = {
             code: 0,

package/dist/cli/publishing.d.ts

@@ -0,0 +1,21 @@
+type Outcome = {
+    code: number;
+    data: Record<string, unknown>;
+    text: string;
+};
+export type PublishingIo = {
+    say: (line: string) => void;
+    openUrl: (url: string) => void;
+    run: (bin: string, args: readonly string[], cwd: string) => Promise<{
+        code: number;
+        output: string;
+    }>;
+    build: () => Promise<Outcome>;
+    sdkVersion: string;
+};
+export declare function login(io: PublishingIo): Promise<Outcome>;
+export declare function pull(io: PublishingIo, name: string | undefined, cwd: string): Promise<Outcome>;
+export declare function publish(io: PublishingIo, root: string, isStarter: boolean): Promise<Outcome>;
+export declare function versions(io: PublishingIo, root: string): Promise<Outcome>;
+export declare function restore(io: PublishingIo, root: string, number: string | undefined): Promise<Outcome>;
+export {};