@wirechunk/cli 0.0.1-rc.3 → 0.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wirechunk/cli",
-  "version": "0.0.1-rc.3",
+  "version": "0.0.2",
   "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 (
@@ -84,6 +65,20 @@ export const createExtensionVersion = async (
     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})
@@ -98,69 +93,27 @@ 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: extConfig.name,
+          versionName,
+          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 +150,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/create-user.ts

@@ -67,8 +67,7 @@ export const createUser = async (
 
   let platformId: string | null | undefined = opts.platformId;
   let orgId: string | null | undefined = opts.orgId;
-  // TODO
-  // let orgPrimary = false;
+  let orgPrimary = false;
 
   try {
     const user = await db.transaction(async (db) => {
@@ -115,7 +114,7 @@ export const createUser = async (
         if (opts.verbose) {
           console.log(`Created org ID ${orgId}`);
         }
-        // orgPrimary = true;
+        orgPrimary = true;
       }
 
       const user = await db.one(
@@ -124,9 +123,13 @@ export const createUser = async (
         )`insert into "Users" ("platformId", "email", "emailVerified", "password", "passwordStatus", "orgId", "role", "status", "firstName", "lastName") values (${platformId}, ${email}, ${opts.emailVerified}, ${password}, 'Ok', ${orgId}, ${role}, ${status}, ${firstName}, ${lastName}) returning "id"`,
       );
 
-      // if (opts.admin) {
-      //   await grantAllUserPlatformPermissions({ userId: user.id, platformId }, db);
-      // }
+      if (orgPrimary) {
+        await db.maybeOne(
+          sql.type(
+            voidSelectSchema,
+          )`update "Orgs" set "primaryUserId" = ${user.id} where "id" = ${orgId}`,
+        );
+      }
 
       return user;
     });

package/src/commands/edit-admin.ts

@@ -1,19 +1,31 @@
+import { cleanSmallId } from '@wirechunk/lib/clean-small-id.ts';
 import { createPool, sql, UniqueIntegrityConstraintViolationError } from 'slonik';
 import { z } from 'zod';
 import type { Env } from '../env.ts';
 import { requireCoreDbUrl } from '../env.ts';
 import { detailedUniqueIntegrityConstraintViolationError } from '../errors.ts';
 import type { WithGlobalOptions } from '../global-options.ts';
+import {
+  grantAllUserPlatformPermissions,
+  revokeAllUserPlatformPermissions,
+} from '../users/permissions.ts';
+import { voidSelectSchema } from '../util.ts';
 
-const findUserSchema = z.object({
+const findPlatformAdminSchema = z.object({
   id: z.string(),
   platformId: z.string(),
+  active: z.boolean(),
+});
+
+const findUserSchema = z.object({
+  id: z.string(),
 });
 
 type EditAdminOptions = {
   platformId: string;
   userId: string;
   owner?: boolean;
+  active?: boolean;
   revokeAllPermissions?: boolean;
 };
 
@@ -22,7 +34,7 @@ export const editAdmin = async (
   env: Env,
 ): Promise<void> => {
   const db = await createPool(requireCoreDbUrl(env));
-  const { platformId, userId, owner, revokeAllPermissions } = opts;
+  const { platformId, userId, owner, active, revokeAllPermissions } = opts;
 
   if (owner && revokeAllPermissions) {
     console.error(
@@ -33,9 +45,9 @@ export const editAdmin = async (
 
   try {
     await db.transaction(async (db) => {
-      const platformAdmin = await db.maybeOne(
+      let platformAdmin = await db.maybeOne(
         sql.type(
-          findUserSchema,
+          findPlatformAdminSchema,
         )`select "id" from "PlatformAdmins" where "platformId" = ${platformId} and "userId" = ${userId}`,
       );
       if (!platformAdmin) {
@@ -46,17 +58,67 @@ export const editAdmin = async (
           throw new Error(`User with ID ${userId} not found`);
         }
       }
-
-      // TODO
-
-      // if (owner) {
-      //   await grantAllUserPlatformPermissions({ userId: id, platformId: user.platformId }, db);
-      //   console.log('Set user as a platform admin');
-      // }
-      // if (revokeAllPermissions) {
-      //   await revokeAllUserPlatformPermissions({ userId: id }, db);
-      //   console.log('Revoked all platform permissions of user');
-      // }
+      if (owner) {
+        if (!platformAdmin) {
+          platformAdmin = await db.one(
+            sql.type(findPlatformAdminSchema)`
+              insert into "PlatformAdmins" ("id", "platformId", "userId", "owner", "active")
+              values (${cleanSmallId()}, ${platformId}, ${userId}, ${active ?? true}, true)
+              returning "id", "platformId", "active"
+            `,
+          );
+        }
+        await grantAllUserPlatformPermissions({ platformAdminId: platformAdmin.id }, db);
+        if (opts.verbose) {
+          console.log('Set the user as an owner on the platform');
+        }
+      } else if (owner === false) {
+        if (platformAdmin) {
+          await db.query(
+            sql.type(voidSelectSchema)`
+            update "PlatformAdmins"
+            set "owner" = false
+            where "id" = ${platformAdmin.id}
+          `,
+          );
+          if (opts.verbose) {
+            console.log('Removed the user’s owner privileges on the platform');
+          }
+        } else {
+          console.log('This user is not an admin on this platform');
+        }
+      }
+      if (typeof active === 'boolean') {
+        if (platformAdmin) {
+          await db.query(
+            sql.type(voidSelectSchema)`
+              update "PlatformAdmins"
+              set "active" = ${active}
+              where "id" = ${platformAdmin.id}
+            `,
+          );
+        } else {
+          if (active) {
+            // Automatically create a platform admin.
+            await db.one(
+              sql.type(voidSelectSchema)`
+                insert into "PlatformAdmins" ("id", "platformId", "userId", "owner", "active")
+                values (${cleanSmallId()}, ${platformId}, ${userId}, false, ${active})
+              `,
+            );
+          } else {
+            console.log('This user is not an admin on this platform');
+          }
+        }
+      }
+      if (revokeAllPermissions) {
+        if (platformAdmin) {
+          await revokeAllUserPlatformPermissions({ platformAdminId: platformAdmin.id }, db);
+          console.log('Revoked all platform permissions of user');
+        } else {
+          console.log('This user is not an admin on this platform');
+        }
+      }
     });
   } catch (e) {
     if (e instanceof UniqueIntegrityConstraintViolationError) {

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));