@wirechunk/cli 0.0.1 → 0.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wirechunk/cli",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "private": false,
   "type": "module",
   "scripts": {
@@ -19,17 +19,22 @@
   "bin": {
     "wirechunk": "build/main.js"
   },
+  "imports": {
+    "#api": "./src/core-api/api.ts"
+  },
   "dependencies": {
     "argon2": "^0.41.1"
   },
   "devDependencies": {
     "@commander-js/extra-typings": "^13.0.0",
+    "@graphql-typed-document-node/core": "^3.2.0",
     "@types/archiver": "^6.0.3",
     "@wirechunk/backend-lib": "0.0.0",
     "@wirechunk/lib": "0.0.0",
     "archiver": "^7.0.1",
     "chalk": "^5.3.0",
     "commander": "^13.0.0",
+    "graphql-request": "^7.1.2",
     "slonik": "^46.3.0",
     "slonik-interceptor-query-logging": "^46.3.0",
     "zod": "^3.24.1"

package/src/commands/bootstrap.ts

@@ -1,11 +1,11 @@
 import { randomUUID } from 'node:crypto';
 import { cleanTinyId } from '@wirechunk/lib/clean-small-id.ts';
+import { normalizeDomain } from '@wirechunk/lib/domains.ts';
 import { normalizeEmailAddress } from '@wirechunk/lib/emails.ts';
 import {
   defaultFormattedDataTemplate,
   defaultNotificationEmailBodyTemplate,
 } from '@wirechunk/lib/mixer/form-formatting-templates.ts';
-import { normalizeDomain } from '@wirechunk/server/site-domains/util.ts';
 import type { DatabasePool } from 'slonik';
 import { createPool, sql } from 'slonik';
 import type { Env } from '../env.ts';

package/src/commands/create-extension-version.ts

@@ -1,7 +1,11 @@
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { parseEnv } from 'node:util';
 import { requireValidExtensionDir } from '@wirechunk/backend-lib/extensions/require-extension-dir.ts';
 import { parseErrorMessage } from '@wirechunk/lib/errors.ts';
 import archiver from 'archiver';
-import { z } from 'zod';
+import { GraphQLClient } from 'graphql-request';
+import { createExtensionVersion as createExtensionVersionRequest } from '../core-api/operations.ts';
 import type { Env } from '../env.ts';
 import { requireApiToken } from '../env.ts';
 import type { WithGlobalOptions } from '../global-options.js';
@@ -16,44 +20,21 @@ const bytesFormat = Intl.NumberFormat('en', {
   maximumFractionDigits: 1,
 });
 
-const createExtensionVersionResultDataSchema = z.discriminatedUnion('__typename', [
-  z.object({
-    __typename: z.literal('CreateExtensionVersionSuccessResult'),
-    extensionVersion: z.object({
-      id: z.string(),
-    }),
-    signedUrl: z.string(),
-  }),
-  z.object({
-    __typename: z.literal('AuthorizationError'),
-    message: z.string(),
-  }),
-  z.object({
-    __typename: z.literal('GenericInternalError'),
-    message: z.string(),
-  }),
-  z.object({
-    __typename: z.literal('GenericUserError'),
-    message: z.string(),
-  }),
-]);
-
-const graphQlErrorSchema = z.object({
-  message: z.string(),
-});
-
-const createExtensionVersionResultSchema = z.object({
-  errors: z.array(graphQlErrorSchema).optional().nullable(),
-  data: z
-    .object({
-      createExtensionVersion: createExtensionVersionResultDataSchema,
-    })
-    .nullable(),
-});
+const ignoreGlobs = [
+  '**/.git/**/*',
+  '.git/**/*',
+  'eslint.config.js',
+  '**/eslint.config.js',
+  'node_modules/**/*',
+  '**/node_modules/**/*',
+  'yalc.lock',
+  '**/yalc.lock',
+];
 
 type CreateExtensionVersionOptions = {
   extensionId?: string;
   versionName: string;
+  configFile?: string;
 };
 
 export const createExtensionVersion = async (
@@ -63,33 +44,47 @@ export const createExtensionVersion = async (
   const extensionId = requireExtensionIdOptionOrEnvVar(opts, env);
   const apiToken = requireApiToken(env);
   const cwd = process.cwd();
-  const extConfig = await requireValidExtensionDir(cwd);
+  const { manifest } = await requireValidExtensionDir(cwd);
   let enableServer: boolean;
   let enableDb: boolean;
-  if (extConfig.server) {
-    enableServer = !!extConfig.server.enable;
-    if (extConfig.server.database?.enable && extConfig.server.enable === false) {
+  if (manifest.server) {
+    enableServer = !!manifest.server.enable;
+    if (manifest.server.database?.enable && manifest.server.enable === false) {
       // Server was explicitly disabled, so don't allow database.
       console.warn('WARNING: Automatically disabling database because server is disabled');
       enableDb = false;
-    } else if (extConfig.server.database?.enable && !extConfig.server.enable) {
+    } else if (manifest.server.database?.enable && !manifest.server.enable) {
       // Server was unspecified, so enable it because database is enabled.
       console.warn('WARNING: Automatically enabling server because database is enabled');
       enableServer = true;
       enableDb = true;
     } else {
-      enableDb = !!extConfig.server.database?.enable;
+      enableDb = !!manifest.server.database?.enable;
     }
   } else {
     enableServer = false;
     enableDb = false;
   }
+  let config: Record<string, string> | null = null;
+  if (opts.configFile) {
+    const configFilePath = resolve(cwd, opts.configFile);
+    if (opts.verbose) {
+      console.log(`Loading config file ${configFilePath}`);
+    }
+    const configFile = await readFile(configFilePath, 'utf8');
+    try {
+      config = parseEnv(configFile) as Record<string, string>;
+    } catch (e) {
+      console.error(`Failed to parse config file at ${configFilePath}:`, parseErrorMessage(e));
+      process.exit(1);
+    }
+  }
 
   const { versionName } = opts;
   console.log(`Creating extension version ${versionName} (Extension ID ${extensionId})
   Server: ${enableServer ? 'enabled' : 'disabled'}
   Database: ${enableDb ? 'enabled' : 'disabled'}
-  Components: ${Object.keys(extConfig.components ?? {}).length}`);
+  Components: ${Object.keys(manifest.components ?? {}).length}`);
 
   let extensionVersionId: string;
   let signedUrl: string;
@@ -98,69 +93,28 @@ export const createExtensionVersion = async (
     if (opts.verbose) {
       console.log(`POST ${url}`);
     }
-    const createResult = await fetch(url, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        Authorization: `Bearer ${apiToken}`,
-      },
-      body: JSON.stringify({
-        query: `
-          mutation ($input: CreateExtensionVersionInput!) {
-            createExtensionVersion(input: $input) {
-              __typename
-              ... on CreateExtensionVersionSuccessResult {
-                extensionVersion {
-                  id
-                }
-                signedUrl
-              }
-              ... on Error {
-                message
-              }
-            }
-          }
-        `,
-        variables: {
-          input: {
-            extensionId,
-            extensionName: extConfig.name,
-            versionName,
-            enableServer,
-            enableDb,
-          },
+    const result = await createExtensionVersionRequest({
+      client: new GraphQLClient(url),
+      variables: {
+        input: {
+          extensionId,
+          extensionName: manifest.name,
+          versionName,
+          manifest: JSON.stringify(manifest),
+          enableServer,
+          enableDb,
+          config: config ? JSON.stringify(config) : undefined,
         },
-      }),
+      },
+      sessionAuthToken: apiToken,
     });
-    if (!createResult.ok) {
-      const message = `Failed to create an extension version (status ${createResult.status})`;
-      try {
-        const data = await createResult.json();
-        console.error(`${message}:`, parseErrorMessage(data));
-        process.exit(1);
-      } catch {
-        console.error(message);
-        process.exit(1);
-      }
-    }
-    const data = await createResult.json();
-    const parseResult = createExtensionVersionResultSchema.safeParse(data);
-    if (!parseResult.success) {
-      console.error('Failed to create an extension version:', parseResult.error.message);
-      process.exit(1);
-    }
-    const result = parseResult.data;
-    if (result.errors) {
-      console.error('Failed to create an extension version:', parseErrorMessage(result));
-      process.exit(1);
-    }
-    if (result.data?.createExtensionVersion.__typename === 'CreateExtensionVersionSuccessResult') {
-      extensionVersionId = result.data.createExtensionVersion.extensionVersion.id;
-      signedUrl = result.data.createExtensionVersion.signedUrl;
+    if (result.createExtensionVersion.__typename === 'CreateExtensionVersionSuccessResult') {
+      extensionVersionId = result.createExtensionVersion.extensionVersion.id;
+      signedUrl = result.createExtensionVersion.signedUrl;
     } else {
       console.error(
-        `Failed to create an extension version (${result.data?.createExtensionVersion.__typename ?? 'unknown error'}):`,
-        parseErrorMessage(result.data?.createExtensionVersion),
+        `Failed to create an extension version (${result.createExtensionVersion.__typename}):`,
+        result.createExtensionVersion.message,
       );
       process.exit(1);
     }
@@ -197,14 +151,7 @@ export const createExtensionVersion = async (
 
   archive.glob('**/*', {
     cwd,
-    ignore: [
-      '**/.git/**/*',
-      '.git/**/*',
-      'eslint.config.js',
-      '**/eslint.config.js',
-      'node_modules/**/*',
-      '**/node_modules/**/*',
-    ],
+    ignore: ignoreGlobs,
   });
 
   if (opts.verbose) {

package/src/commands/ext-dev/{db-connect-info.ts → get-db-url.ts}

@@ -5,13 +5,13 @@ import type { Env } from '../../env.ts';
 import type { WithGlobalOptions } from '../../global-options.js';
 import { getExtensionDbConnectInfo, replaceEnvVar } from '../../util.ts';
 
-type DbConnectInfoOptions = {
+type GetDbUrlOptions = {
   extensionId?: string;
   dbName?: string;
 };
 
-export const dbConnectInfo = async (
-  opts: WithGlobalOptions<DbConnectInfoOptions>,
+export const getDbUrl = async (
+  opts: WithGlobalOptions<GetDbUrlOptions>,
   env: Env,
 ): Promise<void> => {
   const connInfo = getExtensionDbConnectInfo(opts, env);

package/src/commands/ext-dev/init-db.ts

@@ -10,7 +10,7 @@ import {
   getExtensionDbConnectInfo,
   requireExtensionIdOptionOrEnvVar,
 } from '../../util.ts';
-import { dbConnectInfo } from './db-connect-info.ts';
+import { getDbUrl } from './get-db-url.ts';
 
 const initExtDb = async ({
   // A connection to the extension database by a superuser role.
@@ -149,7 +149,8 @@ export const initDb = async (
   const coreDbUrl = requireCoreDbUrl(env);
   const extensionId = requireExtensionIdOptionOrEnvVar(opts, env);
 
-  await dbConnectInfo(opts, env);
+  // This writes the DATABASE_URL environment variable to a .env.local (or .env.<env-mode>.local) file.
+  await getDbUrl(opts, env);
 
   const db = await createPool(coreDbUrl, dbPoolOptions(opts));