@wirechunk/cli 0.0.6 → 0.0.8

package/src/core-api/mutations/create-extension-version.generated.ts

@@ -1,96 +0,0 @@
-import type { TypedDocumentNode as DocumentNode } from '@graphql-typed-document-node/core';
-import type * as Types from '#api';
-
-export type CreateExtensionVersionMutationVariables = Types.Exact<{
-  input: Types.CreateExtensionVersionInput;
-}>;
-
-export type CreateExtensionVersionMutation = {
-  createExtensionVersion:
-    | { __typename: 'AuthorizationError'; message: string }
-    | {
-        __typename: 'CreateExtensionVersionSuccessResult';
-        signedUrl: string;
-        extensionVersion: { __typename: 'ExtensionVersion'; id: string };
-      }
-    | { __typename: 'InternalError'; message: string }
-    | { __typename: 'UserError'; message: string };
-};
-
-export const CreateExtensionVersionDocument = {
-  kind: 'Document',
-  definitions: [
-    {
-      kind: 'OperationDefinition',
-      operation: 'mutation',
-      name: { kind: 'Name', value: 'CreateExtensionVersion' },
-      variableDefinitions: [
-        {
-          kind: 'VariableDefinition',
-          variable: { kind: 'Variable', name: { kind: 'Name', value: 'input' } },
-          type: {
-            kind: 'NonNullType',
-            type: {
-              kind: 'NamedType',
-              name: { kind: 'Name', value: 'CreateExtensionVersionInput' },
-            },
-          },
-        },
-      ],
-      selectionSet: {
-        kind: 'SelectionSet',
-        selections: [
-          {
-            kind: 'Field',
-            name: { kind: 'Name', value: 'createExtensionVersion' },
-            arguments: [
-              {
-                kind: 'Argument',
-                name: { kind: 'Name', value: 'input' },
-                value: { kind: 'Variable', name: { kind: 'Name', value: 'input' } },
-              },
-            ],
-            selectionSet: {
-              kind: 'SelectionSet',
-              selections: [
-                { kind: 'Field', name: { kind: 'Name', value: '__typename' } },
-                {
-                  kind: 'InlineFragment',
-                  typeCondition: {
-                    kind: 'NamedType',
-                    name: { kind: 'Name', value: 'CreateExtensionVersionSuccessResult' },
-                  },
-                  selectionSet: {
-                    kind: 'SelectionSet',
-                    selections: [
-                      {
-                        kind: 'Field',
-                        name: { kind: 'Name', value: 'extensionVersion' },
-                        selectionSet: {
-                          kind: 'SelectionSet',
-                          selections: [{ kind: 'Field', name: { kind: 'Name', value: 'id' } }],
-                        },
-                      },
-                      { kind: 'Field', name: { kind: 'Name', value: 'signedUrl' } },
-                    ],
-                  },
-                },
-                {
-                  kind: 'InlineFragment',
-                  typeCondition: { kind: 'NamedType', name: { kind: 'Name', value: 'Error' } },
-                  selectionSet: {
-                    kind: 'SelectionSet',
-                    selections: [{ kind: 'Field', name: { kind: 'Name', value: 'message' } }],
-                  },
-                },
-              ],
-            },
-          },
-        ],
-      },
-    },
-  ],
-} as unknown as DocumentNode<
-  CreateExtensionVersionMutation,
-  CreateExtensionVersionMutationVariables
->;

package/src/core-api/mutations/create-extension-version.graphql

@@ -1,14 +0,0 @@
-mutation CreateExtensionVersion($input: CreateExtensionVersionInput!) {
-  createExtensionVersion(input: $input) {
-    __typename
-    ... on CreateExtensionVersionSuccessResult {
-      extensionVersion {
-        id
-      }
-      signedUrl
-    }
-    ... on Error {
-      message
-    }
-  }
-}

package/src/core-api/operations.ts

@@ -1,23 +0,0 @@
-import type { GraphQLClient } from 'graphql-request';
-import type {
-  CreateExtensionVersionMutation,
-  CreateExtensionVersionMutationVariables,
-} from './mutations/create-extension-version.generated.ts';
-import { CreateExtensionVersionDocument } from './mutations/create-extension-version.generated.ts';
-
-export const createExtensionVersion = ({
-  client,
-  variables,
-  sessionAuthToken,
-}: {
-  client: GraphQLClient;
-  variables: CreateExtensionVersionMutationVariables;
-  sessionAuthToken: string;
-}): Promise<CreateExtensionVersionMutation> =>
-  client.request({
-    document: CreateExtensionVersionDocument,
-    variables,
-    requestHeaders: {
-      Authorization: `Bearer ${sessionAuthToken}`,
-    },
-  });

package/src/env.ts

@@ -1,85 +0,0 @@
-import { existsSync } from 'node:fs';
-import { readFile } from 'node:fs/promises';
-import process from 'node:process';
-import { parseEnv as parseEnvContents } from 'node:util';
-import { isLocalhost } from '@wirechunk/lib/localhost.ts';
-
-export type Env = Record<string, string> & {
-  CORE_DATABASE_URL?: string;
-  // A URL to the server root, like https://wirechunk.com or http://localhost:8080
-  CORE_SERVER_URL: string;
-  WIRECHUNK_API_TOKEN?: string;
-};
-
-// A .env file is required only if the required environment variables are not already set.
-const envFilePath = '.env';
-const envLocalFilePath = '.env.local';
-
-const hasEnvFile = existsSync(envFilePath);
-
-export const requireApiToken = (env: Env): string => {
-  if (!env.WIRECHUNK_API_TOKEN) {
-    console.error(
-      'Missing API token for authentication. Provide a WIRECHUNK_API_TOKEN environment variable.',
-    );
-    process.exit(1);
-  }
-  return env.WIRECHUNK_API_TOKEN;
-};
-
-export const requireCoreDbUrl = (env: Env): string => {
-  if (!env.CORE_DATABASE_URL) {
-    if (hasEnvFile) {
-      console.error('Missing CORE_DATABASE_URL in environment');
-    } else {
-      console.error(`Missing CORE_DATABASE_URL in environment, no ${envFilePath} file found`);
-    }
-    process.exit(1);
-  }
-  return env.CORE_DATABASE_URL;
-};
-
-const coreServerUrlFromEnv = (env: Record<string, string>): string => {
-  const url = env.CORE_SERVER_URL;
-  if (url) {
-    return url.endsWith('/api') ? url.substring(0, url.length - 4) : url;
-  }
-  const adminDomain = env.ADMIN_DOMAIN;
-  if (adminDomain) {
-    return isLocalhost(adminDomain) ? `http://${adminDomain}` : `https://${adminDomain}`;
-  }
-  return 'https://wirechunk.com';
-};
-
-export const parseEnv = async (envMode: string | undefined): Promise<Env> => {
-  const env: Record<string, string> = {};
-
-  if (hasEnvFile) {
-    const envFileRaw = await readFile(envFilePath, 'utf8');
-    Object.assign(env, parseEnvContents(envFileRaw));
-  }
-  if (envMode) {
-    const modeFilePath = `.env.${envMode}`;
-    if (existsSync(modeFilePath)) {
-      const modeFileRaw = await readFile(modeFilePath, 'utf8');
-      Object.assign(env, parseEnvContents(modeFileRaw));
-    }
-  }
-  if (existsSync(envLocalFilePath)) {
-    const envLocalFileRaw = await readFile(envLocalFilePath, 'utf8');
-    Object.assign(env, parseEnvContents(envLocalFileRaw));
-  }
-  if (envMode) {
-    const modeLocalFilePath = `.env.${envMode}.local`;
-    if (existsSync(modeLocalFilePath)) {
-      const modeLocalFileRaw = await readFile(modeLocalFilePath, 'utf8');
-      Object.assign(env, parseEnvContents(modeLocalFileRaw));
-    }
-  }
-  Object.assign(env, process.env);
-
-  return {
-    ...env,
-    CORE_SERVER_URL: coreServerUrlFromEnv(env),
-  };
-};

package/src/errors.ts

@@ -1,30 +0,0 @@
-import type { UniqueIntegrityConstraintViolationError } from 'slonik';
-
-export const detailedUniqueIntegrityConstraintViolationError = (
-  error: UniqueIntegrityConstraintViolationError,
-): string => {
-  // The default error message is not very helpful, so we provide a more specific one.
-  const message =
-    error.message === 'Query violates a unique integrity constraint.'
-      ? `A database uniqueness constraint was violated when inserting or updating`
-      : error.message;
-  const details: string[] = [];
-  if (error.table) {
-    details.push(`table "${error.table}"`);
-  }
-  if (error.column) {
-    details.push(`column "${error.column}"`);
-  }
-  if (error.constraint) {
-    details.push(`constraint "${error.constraint}"`);
-  }
-  if (details.length) {
-    return `${message} (${details.join(', ')})`;
-  }
-  return message;
-};
-
-// Returns true if error is an object with a code property that signifies there is a duplicate database.
-// Note the expected shape comes from the 'pg' library.
-export const isDuplicateDatabaseError = (error: unknown): boolean =>
-  !!error && typeof error === 'object' && 'code' in error && error.code === '42P04';

package/src/global-options.ts

@@ -1,6 +0,0 @@
-export type GlobalOptions = {
-  verbose?: boolean;
-  envMode?: string;
-};
-
-export type WithGlobalOptions<T> = T & GlobalOptions;

package/src/main.ts

@@ -1,136 +0,0 @@
-#!/usr/bin/env node
-
-import type { OptionValues } from '@commander-js/extra-typings';
-import { Command } from '@commander-js/extra-typings';
-import chalk from 'chalk';
-import { bootstrap } from './commands/bootstrap.ts';
-import { createExtensionVersion } from './commands/create-extension-version.ts';
-import { createUser } from './commands/create-user.ts';
-import { editAdmin } from './commands/edit-admin.ts';
-import { getDbUrl } from './commands/ext-dev/get-db-url.ts';
-import { initDb } from './commands/ext-dev/init-db.ts';
-import type { Env } from './env.ts';
-import { parseEnv } from './env.ts';
-import type { WithGlobalOptions } from './global-options.ts';
-
-const program = new Command()
-  .name('wirechunk')
-  .option('--verbose', 'output debug logging')
-  .option(
-    '--env-mode <mode>',
-    'the mode to use for finding .env files to load environment variables, such as "test" to load .env, .env.test, .env.local, and .env.test.local; also for finding config files to include when creating an extension or extension version, such as config.production.json',
-  ).description(`The official Wirechunk CLI
-
-By default, environment variables are loaded from the .env file in the current working directory,
-then the .env.local file, and then from the environment. Variables from the environment have the
-highest precedence.
-
-Environment variables used by some commands:
-  CORE_SERVER_URL (the core admin server URL for commands using the API)
-  CORE_DATABASE_URL (the core database URL for commands requiring direct database access)`);
-
-const withOptionsAndEnv =
-  <Args extends string[], Options extends OptionValues>(
-    action: (options: WithGlobalOptions<Options>, env: Env) => Promise<void> | void,
-  ) =>
-  async (options: Options, cmd: Command<Args, Options>) => {
-    const mergedOptions = { ...program.opts(), ...options };
-    if (mergedOptions.verbose) {
-      console.log(`Running ${chalk.green.bold(cmd.name())}`);
-    }
-    const env = await parseEnv(mergedOptions.envMode);
-    return action(mergedOptions, env);
-  };
-
-program
-  .command('bootstrap')
-  .description('create a platform')
-  .requiredOption('--name <string>', 'the name of the platform')
-  .option('--handle <string>', 'the handle of the platform (used by the admin site)')
-  .requiredOption(
-    '--admin-site-domain <string>',
-    'the domain of the platform admin site (dashboard)',
-  )
-  .option(
-    '--email-send-from <string>',
-    'the email address from which to send emails, defaults to "site@<admin-site-domain>',
-  )
-  .action(withOptionsAndEnv(bootstrap));
-
-program
-  .command('create-extension-version')
-  .description('create an extension version')
-  .option(
-    '--extension-id <string>',
-    'the ID of the extension, can be set with an EXTENSION_ID environment variable instead',
-  )
-  .requiredOption('--version-name <string>', 'the name of the version')
-  .option(
-    '--config-file <string>',
-    'the path to a file to use when creating the extension version, containing environment-style key-value pairs',
-  )
-  .action(withOptionsAndEnv(createExtensionVersion));
-
-program
-  .command('create-user')
-  .description('create a user')
-  .requiredOption('--email <string>', 'the email address of the user')
-  .requiredOption('--password <string>', 'the password of the user')
-  .requiredOption('--first-name <string>', 'the first name of the user')
-  .requiredOption('--last-name <string>', 'the last name of the user')
-  .option(
-    '--org-id <string>',
-    'the ID of the org to which the user belongs, defaults to creating a new org if not specified',
-  )
-  .option(
-    '--platform-id <string>',
-    'the ID of the platform ID to which the users will be added, used only if org ID is not specified',
-  )
-  .option(
-    '--role <string>',
-    'the role the user will have (defaults to the default role set on the platform, if defined, or an empty string)',
-  )
-  .option('--email-verified', 'mark the email address as already verified by the user', false)
-  .option('--pending', 'create the user in a pending state', false)
-  .action(withOptionsAndEnv(createUser));
-
-// TODO: create-admin
-
-const extDev = program.command('ext-dev').description('extension development commands');
-
-extDev
-  .command('get-db-url')
-  .description(
-    'write the connection info for the extension database to a .env.local or .env.<env-mode>.local file',
-  )
-  .option(
-    '--extension-id <string>',
-    'the ID of the extension, can be set with an EXTENSION_ID environment variable instead',
-  )
-  .action(withOptionsAndEnv(getDbUrl));
-
-extDev
-  .command('init-db')
-  .description(
-    'initialize a development database for an extension, useful for testing, assumes the extension role exists',
-  )
-  .option(
-    '--extension-id <string>',
-    'the ID of the extension, can be set with an EXTENSION_ID environment variable instead',
-  )
-  .option('--db-name <string>', 'a custom name for the database, applicable only for testing')
-  .action(withOptionsAndEnv(initDb));
-
-program
-  .command('edit-admin')
-  .description('edit a platform admin user or make a user a platform admin')
-  .requiredOption('--platform-id <string>', 'the ID of the platform to edit')
-  .requiredOption('--user-id <string>', 'the ID of the admin user to edit')
-  .option('--owner', 'grants the user full permission to manage everything on the platform')
-  .option('--no-owner', 'removes owner privileges on the platform')
-  .option('--active', 'activates or deactivates the user’s admin access on the platform')
-  .option('--no-active', 'deactivates the user’s admin access on the platform')
-  .option('--revoke-all-permissions', 'revokes all permission of the user on their platform')
-  .action(withOptionsAndEnv(editAdmin));
-
-await program.parseAsync();

package/src/users/permissions.ts

@@ -1,41 +0,0 @@
-import { cleanSmallId } from '@wirechunk/lib/clean-small-id.ts';
-import { allPermissions } from '@wirechunk/lib/permissions.ts';
-import type { CommonQueryMethods } from 'slonik';
-import { sql } from 'slonik';
-import { voidSelectSchema } from '../util.ts';
-
-export const revokeAllUserPlatformPermissions = async (
-  {
-    platformAdminId,
-  }: {
-    platformAdminId: string;
-  },
-  db: CommonQueryMethods,
-): Promise<void> => {
-  await db.query(
-    sql.type(
-      voidSelectSchema,
-    )`delete from "Permissions" where "platformAdminId" = ${platformAdminId}`,
-  );
-};
-
-export const grantAllUserPlatformPermissions = async (
-  {
-    platformAdminId,
-  }: {
-    platformAdminId: string;
-  },
-  db: CommonQueryMethods,
-): Promise<void> => {
-  await db.query(
-    sql.type(
-      voidSelectSchema,
-    )`insert into "Permissions" ("id", "platformAdminId", "object", "action") values ${sql.join(
-      allPermissions.map(
-        (permission) =>
-          sql.fragment`(${cleanSmallId()}, ${platformAdminId}, ${permission.object}, ${permission.action})`,
-      ),
-      sql.fragment`,`,
-    )} on conflict ("platformAdminId", "object", "action") do nothing`,
-  );
-};

package/src/util.ts

@@ -1,81 +0,0 @@
-import type { ClientConfigurationInput } from 'slonik/src/types.js';
-import { createQueryLoggingInterceptor } from 'slonik-interceptor-query-logging';
-import { z } from 'zod';
-import type { Env } from './env.ts';
-import { requireCoreDbUrl } from './env.ts';
-import type { GlobalOptions } from './global-options.ts';
-
-// Returns the name to use for an extension's database in development mode.
-export const extensionDbName = (id: string): string => `ext_${id}`;
-
-export const voidSelectSchema = z.object({});
-
-export const requireExtensionIdOptionOrEnvVar = (
-  options: { extensionId?: string },
-  env: Env,
-): string => {
-  const extensionId = options.extensionId || env.EXTENSION_ID;
-  if (!extensionId) {
-    console.error(
-      'Missing an extension ID, must be specified either as the --extension-id argument or the EXTENSION_ID environment variable',
-    );
-    process.exit(1);
-  }
-  return extensionId;
-};
-
-// Returns the value for the interceptors property to use on a Slonik ClientConfigurationInput.
-// Note that you still need to set a ROARR_LOG=true environment variable to enable logging.
-export const dbPoolOptions = (opts: GlobalOptions): ClientConfigurationInput =>
-  opts.verbose ? { interceptors: [createQueryLoggingInterceptor({ logValues: true })] } : {};
-
-// Replace instances of a variable, or add a variable if needed, preserving other lines.
-export const replaceEnvVar = (lines: string[], name: string, value: string): string[] => {
-  const newLines: string[] = [];
-  let hasName = false;
-  const namePattern = new RegExp(String.raw`^\s*${name}\s*=\s*`);
-  for (const line of lines) {
-    if (namePattern.test(line)) {
-      if (!hasName) {
-        newLines.push(`${name}=${value}`);
-        hasName = true;
-      }
-    } else {
-      newLines.push(line);
-    }
-  }
-  if (!hasName) {
-    newLines.push(`${name}=${value}`);
-  }
-  return newLines;
-};
-
-export const replaceDbName = (url: URL, dbName: string): URL => {
-  const urlObj = new URL(url.toString());
-  urlObj.pathname = `/${dbName}`;
-  return urlObj;
-};
-
-export type DbConnectInfo = {
-  url: URL;
-  dbName: string;
-};
-
-export const getExtensionDbConnectInfo = (
-  opts: {
-    extensionId?: string;
-    dbName?: string;
-  },
-  env: Env,
-): DbConnectInfo => {
-  const extensionId = requireExtensionIdOptionOrEnvVar(opts, env);
-  const dbName = opts.dbName || extensionDbName(extensionId);
-  const url = replaceDbName(new URL(requireCoreDbUrl(env)), dbName);
-  url.username = `ext_${extensionId}`;
-  url.password = '';
-
-  return {
-    url,
-    dbName,
-  };
-};

package/tsconfig.build.json

@@ -1,10 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "exclude": ["**/*.test.ts", "tests/**"],
-  "compilerOptions": {
-    "outDir": "build",
-    "noEmit": false,
-    "skipLibCheck": true,
-    "removeComments": true
-  }
-}

package/tsconfig.json

@@ -1,26 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2023",
-    "lib": ["ES2024", "ESNext.Promise"],
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "allowImportingTsExtensions": true,
-    "resolveJsonModule": true,
-    "allowJs": false,
-    "sourceMap": true,
-    "esModuleInterop": true,
-    "isolatedModules": true,
-    "forceConsistentCasingInFileNames": true,
-    "noFallthroughCasesInSwitch": true,
-    "strict": true,
-    "strictNullChecks": true,
-    "noImplicitReturns": true,
-    "noUncheckedIndexedAccess": true,
-    "noUnusedLocals": true,
-    "skipLibCheck": false,
-    "noEmit": true,
-    "paths": {
-      "#api": ["./src/core-api/api.ts"]
-    }
-  }
-}

package/vite.config.ts

@@ -1,18 +0,0 @@
-import { resolve } from 'node:path';
-import { defineConfig } from 'vite';
-
-export default defineConfig({
-  ssr: {
-    // Every dependency except for built-in node dependencies are inlined.
-    noExternal: [/^(?!node:).*/],
-    external: ['argon2'],
-  },
-  build: {
-    ssr: true,
-    target: 'node22',
-    rollupOptions: {
-      input: resolve(import.meta.dirname, 'src/main.ts'),
-    },
-    outDir: 'build',
-  },
-});