instant-cli 0.22.120 → 0.22.121-experimental.drewh-clief.21610676979.1

package/src/new/context/currentApp.ts

@@ -0,0 +1,207 @@
+import { HttpClientRequest, HttpClientResponse } from '@effect/platform';
+import { randomUUID } from 'crypto';
+import { Context, Data, Effect, Layer, Runtime, Schema } from 'effect';
+import { UI } from '../../ui/index.js';
+import { handleEnv } from '../lib/handleEnv.js';
+import { getBaseUrl, InstantHttpAuthed } from '../lib/http.js';
+import { runUIEffect } from '../lib/ui.js';
+import { AuthToken } from './authToken.js';
+import { GlobalOpts } from './globalOpts.js';
+import { PlatformApi } from './platformApi.js';
+
+export type CurrentAppInfo = {
+  appId: string;
+  adminToken?: string;
+  source: 'create' | 'import' | 'env' | 'flag' | 'ephemeral';
+};
+
+export class CurrentApp extends Context.Tag(
+  'instant-cli/new/context/currentApp',
+)<CurrentApp, CurrentAppInfo>() {}
+
+function isUUID(uuid) {
+  const uuidRegex =
+    /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+  return uuidRegex.test(uuid);
+}
+
+export class CurrentAppContextError extends Data.TaggedError(
+  'CurrentAppContextError',
+)<{
+  message: string;
+}> {}
+
+export class AppNotFoundError extends Data.TaggedError('AppNotFoundError')<{
+  message: string;
+}> {}
+
+export const potentialEnvs: Record<string, string> = {
+  catchall: 'INSTANT_APP_ID',
+  next: 'NEXT_PUBLIC_INSTANT_APP_ID',
+  svelte: 'PUBLIC_INSTANT_APP_ID',
+  vite: 'VITE_INSTANT_APP_ID',
+  expo: 'EXPO_PUBLIC_INSTANT_APP_ID',
+  nuxt: 'NUXT_PUBLIC_INSTANT_APP_ID',
+};
+
+// TODO: add instant.config.ts support
+export const CurrentAppLive = (args: {
+  appId?: string;
+  coerce?: boolean;
+  title?: string;
+  applyEnv?: boolean;
+}) =>
+  Layer.effect(
+    CurrentApp,
+    Effect.gen(function* () {
+      if (args.appId) {
+        return {
+          appId: args.appId,
+          source: 'flag' as const,
+        };
+      }
+
+      // Detect from ENV
+      const found = Object.keys(potentialEnvs)
+        .map((type) => {
+          const envName = potentialEnvs[type];
+          const value = process.env[envName];
+          return { type, envName, value };
+        })
+        .find(({ value }) => !!value);
+
+      if (found?.value && !isUUID(found.value)) {
+        return yield* new CurrentAppContextError({
+          message: `Invalid UUID: ${found.value}`,
+        });
+      } else if (found?.value) {
+        return {
+          appId: found?.value,
+          source: 'env' as const,
+        };
+      }
+      return yield* new AppNotFoundError({
+        message: 'No app found',
+      });
+    }).pipe(
+      // coerce into new app if app not found
+      Effect.catchTag('AppNotFoundError', () =>
+        Effect.gen(function* () {
+          if (!args.coerce)
+            return yield* new AppNotFoundError({ message: 'No app found' });
+
+          // coerce into a new app
+          const globalOpts = yield* GlobalOpts;
+          if (globalOpts.yes) {
+            if (!args.title) {
+              return yield* new CurrentAppContextError({
+                message: `Title is required when using --yes and no app is linked`,
+              });
+            } else {
+              return yield* createApp(args.title);
+            }
+          }
+
+          return yield* promptImportOrCreateApp;
+        }),
+      ),
+
+      // Handle save env
+      Effect.tap((app) =>
+        Effect.gen(function* () {
+          if (
+            args.applyEnv &&
+            (app.source === 'import' || app.source == 'create')
+          ) {
+            yield* handleEnv(app);
+          }
+        }),
+      ),
+    ),
+  );
+
+const createApp = Effect.fn(function* (title: string, orgId?: string) {
+  const id = randomUUID();
+  const token = randomUUID();
+  const app = { id, title, admin_token: token, org_id: orgId };
+
+  const http = yield* InstantHttpAuthed;
+  yield* HttpClientRequest.post('/dash/apps').pipe(
+    HttpClientRequest.bodyJson(app),
+    Effect.flatMap(http.execute),
+  );
+  return {
+    appId: id,
+    source: 'create',
+    adminToken: token,
+  } satisfies CurrentAppInfo;
+});
+
+const promptImportOrCreateApp = Effect.gen(function* () {
+  const api = yield* getSimpleApi;
+  const result = yield* runUIEffect(
+    new UI.AppSelector({
+      allowEphemeral: true,
+      allowCreate: true,
+      api,
+    }),
+  );
+
+  return {
+    appId: result.appId,
+    source: result.approach,
+    adminToken: result.adminToken,
+  } satisfies CurrentAppInfo;
+});
+
+const getSimpleApi = Effect.gen(function* () {
+  const effectRuntime = yield* Effect.runtime<never>();
+
+  const http = yield* InstantHttpAuthed;
+  const dashData = yield* http
+    .get('/dash')
+    .pipe(Effect.flatMap(HttpClientResponse.schemaBodyJson(Schema.Any)));
+  const platform = yield* PlatformApi;
+
+  const baseUrl = yield* getBaseUrl;
+  const { authToken } = yield* AuthToken;
+
+  return {
+    getDash: () => dashData,
+    createApp: async (title, orgId) => {
+      return Runtime.runPromise(
+        effectRuntime,
+        createApp(title, orgId).pipe(
+          Effect.provideService(InstantHttpAuthed, http),
+        ),
+      );
+    },
+
+    createEphemeralApp: async (title) => {
+      return await Runtime.runPromise(
+        effectRuntime,
+        Effect.gen(function* () {
+          const platform = yield* PlatformApi;
+          const response = yield* platform.use(
+            (p) => p.createTemporaryApp({ title: title }),
+            'Error creating temporary app',
+          );
+          return {
+            appId: response.app.id,
+            adminToken: response.app.adminToken,
+          };
+        }).pipe(Effect.provideService(PlatformApi, platform)),
+      );
+    },
+
+    async getAppsForOrg(orgId) {
+      const response = await fetch(baseUrl + '/dash/orgs/' + orgId, {
+        headers: {
+          Authorization: `Bearer ${authToken}`,
+        },
+      });
+      const data = await response.json();
+      return { apps: data.apps };
+    },
+  } satisfies UI.AppSelectorApi;
+});

package/src/new/context/globalOpts.ts

@@ -0,0 +1,22 @@
+import { program } from 'commander';
+import { Context, Effect, Layer } from 'effect';
+
+export class GlobalOpts extends Context.Tag(
+  'instant-cli/new/context/globalOpts',
+)<
+  GlobalOpts,
+  {
+    token?: string;
+    yes: boolean;
+    env?: string;
+  }
+>() {}
+
+export const GlobalOptsLive = Layer.effect(
+  GlobalOpts,
+  Effect.gen(function* () {
+    return {
+      yes: program.optsWithGlobals()?.yes || false,
+    };
+  }),
+);

package/src/new/context/platformApi.ts

@@ -0,0 +1,35 @@
+import { Data, Effect, Schema } from 'effect';
+import { getBaseUrl } from '../lib/http.js';
+import { PlatformApi as InstantPlatformApi } from '@instantdb/platform';
+
+export class PlatformApiError extends Data.TaggedError('PlatformApiError')<{
+  message: string;
+  cause: unknown;
+}> {}
+
+export class PlatformApi extends Effect.Service<PlatformApi>()(
+  'instant-cli/new/context/platformApi',
+  {
+    effect: Effect.gen(function* () {
+      const origin = yield* getBaseUrl;
+      const apiClient = new InstantPlatformApi({
+        apiURI: origin,
+      });
+
+      return {
+        use: <R>(
+          fun: (api: typeof apiClient) => Promise<R>,
+          errorMessage?: string,
+        ) =>
+          Effect.tryPromise({
+            try: (_signal) => fun(apiClient),
+            catch: (e) =>
+              new PlatformApiError({
+                message: errorMessage || 'Error using platform api',
+                cause: e,
+              }),
+          }),
+      };
+    }),
+  },
+) {}

package/src/new/context/projectInfo.ts

@@ -0,0 +1,172 @@
+import { Context, Data, Effect, Layer } from 'effect';
+import { detect } from 'package-manager-detector/detect';
+import { PackageJson, readPackage } from 'pkg-types';
+
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { UI } from '../../ui/index.js';
+import { findProjectDir } from '../../util/projectDir.js';
+import { runUIEffect } from '../lib/ui.js';
+
+export class ProjectInfo extends Context.Tag(
+  'instant-cli/new/context/projectInfo',
+)<
+  ProjectInfo,
+  {
+    pkgDir: string;
+    projectType: 'node' | 'deno';
+    instantModuleName: string;
+  }
+>() {}
+
+const execAsync = promisify(exec);
+
+export const PACKAGE_ALIAS_AND_FULL_NAMES = {
+  react: '@instantdb/react',
+  'react-native': '@instantdb/react-native',
+  core: '@instantdb/core',
+  admin: '@instantdb/admin',
+};
+
+export class ProjectInfoError extends Data.TaggedError('ProjectInfoError')<{
+  message: string;
+  cause?: unknown;
+}> {}
+
+const getProjectInfo = (
+  coerce: boolean = true,
+  packageName?: keyof typeof PACKAGE_ALIAS_AND_FULL_NAMES,
+) =>
+  Effect.gen(function* () {
+    const projectDir = yield* Effect.tryPromise({
+      try: () => findProjectDir(),
+      catch: (e) =>
+        new ProjectInfoError({ message: "Couldn't get project dir" }),
+    });
+
+    if (!projectDir) {
+      return yield* new ProjectInfoError({
+        message: "Couldn't find a project directory (package.json)",
+      });
+    }
+
+    if (projectDir.type === 'deno') {
+      return {
+        pkgDir: projectDir.dir,
+        projectType: projectDir.type,
+        instantModuleName: '@instantdb/core',
+      };
+    }
+
+    const pkgJson = yield* Effect.tryPromise({
+      try: () => readPackage(),
+      catch: () =>
+        new ProjectInfoError({ message: "Couldn't read package.json" }),
+    });
+
+    let moduleName = getInstantModuleName(pkgJson);
+    if (!moduleName && !coerce) {
+      return yield* new ProjectInfoError({
+        message: 'No instant client library installed',
+      });
+    }
+
+    // TODO: Clean up with option
+    const packageManager = yield* Effect.tryPromise(() => detect()).pipe(
+      Effect.flatMap(Effect.fromNullable),
+      Effect.mapError(
+        () =>
+          new ProjectInfoError({
+            message: 'Failed to detect package manager',
+          }),
+      ),
+    );
+
+    if (!moduleName && coerce) {
+      // install the packages
+      if (packageName) {
+        moduleName = PACKAGE_ALIAS_AND_FULL_NAMES[packageName];
+      } else {
+        moduleName = yield* runUIEffect(
+          new UI.Select({
+            promptText: 'Which package would you like to use?',
+            options: [
+              { label: '@instantdb/react', value: '@instantdb/react' },
+              {
+                label: '@instantdb/react-native',
+                value: '@instantdb/react-native',
+              },
+              { label: '@instantdb/core', value: '@instantdb/core' },
+              { label: '@instantdb/admin', value: '@instantdb/admin' },
+            ],
+          }),
+        ).pipe(
+          Effect.flatMap(Effect.fromNullable),
+          Effect.mapError(
+            () =>
+              new ProjectInfoError({
+                message: 'Failed to select package',
+              }),
+          ),
+        );
+      }
+      const packagesToInstall = [moduleName];
+      if (moduleName === '@instantdb/react-native') {
+        packagesToInstall.push(
+          'react-native-get-random-values',
+          '@react-native-async-storage/async-storage',
+        );
+      }
+      const installCommand = getInstallCommand(
+        packageManager.agent,
+        packagesToInstall.join(' '),
+      );
+      console.log(installCommand);
+      yield* runUIEffect(
+        new UI.Spinner({
+          promise: execAsync(installCommand, {
+            cwd: projectDir.dir,
+          }),
+          errorText: 'Failed to install packages',
+          workingText: `Installing ${packagesToInstall.join(', ')} using ${packageManager.agent}...`,
+          doneText: `Installed ${packagesToInstall.join(', ')} using ${packageManager.agent}.`,
+        }),
+      );
+      return {
+        pkgDir: projectDir.dir,
+        projectType: projectDir.type,
+        instantModuleName: moduleName,
+      };
+    } else {
+      return {
+        pkgDir: projectDir.dir,
+        projectType: projectDir.type,
+        instantModuleName: moduleName!,
+      };
+    }
+  });
+
+export const ProjectInfoLive = (
+  coerce: boolean = true,
+  packageName?: keyof typeof PACKAGE_ALIAS_AND_FULL_NAMES,
+) => Layer.effect(ProjectInfo, getProjectInfo(coerce, packageName));
+
+function getInstantModuleName(pkgJson: PackageJson) {
+  const deps = pkgJson.dependencies || {};
+  const devDeps = pkgJson.devDependencies || {};
+  const instantModuleName = [
+    '@instantdb/react',
+    '@instantdb/react-native',
+    '@instantdb/core',
+    '@instantdb/admin',
+  ].find((name) => deps[name] || devDeps[name]);
+  return instantModuleName;
+}
+
+function getInstallCommand(packageManager: string, moduleName: string) {
+  if (packageManager === 'npm') {
+    return `npm install ${moduleName}`;
+  } else {
+    return `${packageManager} add ${moduleName}`;
+  }
+}

package/src/new/errors.ts

@@ -0,0 +1,7 @@
+import { Schema } from 'effect';
+
+export class BadArgsError extends Schema.TaggedError<BadArgsError>(
+  'BadArgsError',
+)('BadArgsError', {
+  message: Schema.String,
+}) {}

package/src/new/index.ts

@@ -0,0 +1,245 @@
+import { Command, Option, program } from '@commander-js/extra-typings';
+import chalk from 'chalk';
+import { Effect } from 'effect';
+import version from '../version.js';
+import { initCommand } from './commands/init.js';
+import { initWithoutFilesCommand } from './commands/initWithoutFiles.js';
+import { loginCommand } from './commands/login.js';
+import { logoutCommand } from './commands/logout.js';
+import { loadEnv } from '../util/loadEnv.js';
+import {
+  AuthLayerLive,
+  BaseLayerLive,
+  printRedErrors,
+  WithAppLayer,
+} from './layer.js';
+
+loadEnv();
+
+export type ArgsFromCommand<C> =
+  C extends Command<any, infer R, any> ? R : never;
+
+program
+  .name('instant-cli')
+  .addOption(globalOption('-t --token <token>', 'Auth token override'))
+  .addOption(globalOption('-y --yes', "Answer 'yes' to all prompts"))
+  .addOption(globalOption('--env <file>', 'Use a specific .env file'))
+  .addOption(
+    globalOption('-v --version', 'Print the version number', () => {
+      console.log(version);
+      process.exit(0);
+    }),
+  )
+  .addHelpOption(globalOption('-h --help', 'Print the help text for a command'))
+  .usage(`<command> ${chalk.dim('[options] [args]')}`);
+
+// Command List
+export const initDef = program
+  .command('init')
+  .description('Set up a new project.')
+  .option(
+    '-a --app <app-id>',
+    'If you have an existing app ID, we can pull schema and perms from there.',
+  )
+  .option(
+    '-p --package <react|react-native|core|admin>',
+    'Which package to automatically install if there is not one installed already.',
+  )
+  .option('--title <title>', 'Title for the created app')
+  .action((options) => {
+    return Effect.runPromise(
+      initCommand(options).pipe(
+        Effect.provide(
+          WithAppLayer({
+            coerce: true,
+            title: options.title,
+            appId: options.app,
+            packageName: options.package as any,
+            applyEnv: true,
+          }),
+        ),
+        printRedErrors,
+      ),
+    );
+  });
+
+export const initWithoutFilesDef = program
+  .command('init-without-files')
+  .description('Generate a new app id and admin token pair without any files.')
+  .option('--title <title>', 'Title for the created app.')
+  .option(
+    '--org-id <org-id>',
+    'Organization id for app. Cannot be used with --temp flag.',
+  )
+  .option(
+    '--temp',
+    'Create a temporary app which will automatically delete itself after >24 hours.',
+  )
+  .action((opts) => {
+    return Effect.runPromise(
+      initWithoutFilesCommand(opts).pipe(
+        Effect.provide(AuthLayerLive),
+        printRedErrors,
+      ),
+    );
+  });
+
+export const loginDef = program
+  .command('login')
+  .description('Log into your account')
+  .option('-p --print', 'Prints the auth token into the console.')
+  .option(
+    '--headless',
+    'Print the login URL instead of trying to open the browser',
+  )
+  .action(async (opts) => {
+    Effect.runPromise(
+      loginCommand(opts).pipe(Effect.provide(BaseLayerLive), printRedErrors),
+    );
+  });
+
+const _logoutDef = program
+  .command('logout')
+  .description('Log out of your Instant account')
+  .action(async () => {
+    Effect.runPromise(
+      logoutCommand().pipe(Effect.provide(BaseLayerLive), printRedErrors),
+    );
+  });
+
+//// Program setup /////
+
+function globalOption(
+  flags: string,
+  description?: string,
+  argParser?: (value: string, prev?: unknown) => unknown,
+) {
+  const opt = new Option(flags, description);
+  if (argParser) {
+    opt.argParser(argParser);
+  }
+  // @ts-ignore
+  // __global does not exist on `Option`,
+  // but we use it in `getLocalAndGlobalOptions`, to produce
+  // our own custom list of local and global options.
+  // For more info, see the original PR:
+  // https://github.com/instantdb/instant/pull/505
+  opt.__global = true;
+  return opt;
+}
+
+function getLocalAndGlobalOptions(cmd, helper) {
+  const mixOfLocalAndGlobal = helper.visibleOptions(cmd);
+  const localOptionsFromMix = mixOfLocalAndGlobal.filter(
+    (option) => !option.__global,
+  );
+  const globalOptionsFromMix = mixOfLocalAndGlobal.filter(
+    (option) => option.__global,
+  );
+  const globalOptions = helper.visibleGlobalOptions(cmd);
+
+  return [localOptionsFromMix, globalOptionsFromMix.concat(globalOptions)];
+}
+
+function formatHelp(cmd, helper) {
+  const termWidth = helper.padWidth(cmd, helper);
+  const helpWidth = helper.helpWidth || 80;
+  const itemIndentWidth = 2;
+  const itemSeparatorWidth = 2; // between term and description
+  function formatItem(term, description) {
+    if (description) {
+      const fullText = `${term.padEnd(termWidth + itemSeparatorWidth)}${description}`;
+      return helper.wrap(
+        fullText,
+        helpWidth - itemIndentWidth,
+        termWidth + itemSeparatorWidth,
+      );
+    }
+    return term;
+  }
+  function formatList(textArray) {
+    return textArray.join('\n').replace(/^/gm, ' '.repeat(itemIndentWidth));
+  }
+
+  // Usage
+  let output = [`${helper.commandUsage(cmd)}`, ''];
+
+  // Description
+  const commandDescription = helper.commandDescription(cmd);
+  if (commandDescription.length > 0) {
+    output = output.concat([helper.wrap(commandDescription, helpWidth, 0), '']);
+  }
+
+  // Arguments
+  const argumentList = helper.visibleArguments(cmd).map((argument) => {
+    return formatItem(
+      helper.argumentTerm(argument),
+      helper.argumentDescription(argument),
+    );
+  });
+  if (argumentList.length > 0) {
+    output = output.concat([
+      chalk.dim.bold('Arguments'),
+      formatList(argumentList),
+      '',
+    ]);
+  }
+  const [visibleOptions, visibleGlobalOptions] = getLocalAndGlobalOptions(
+    cmd,
+    helper,
+  );
+
+  // Options
+  const optionList = visibleOptions.map((option) => {
+    return formatItem(
+      helper.optionTerm(option),
+      helper.optionDescription(option),
+    );
+  });
+  if (optionList.length > 0) {
+    output = output.concat([
+      chalk.dim.bold('Options'),
+      formatList(optionList),
+      '',
+    ]);
+  }
+  // Commands
+  const commandList = helper.visibleCommands(cmd).map((cmd) => {
+    return formatItem(
+      helper.subcommandTerm(cmd),
+      helper.subcommandDescription(cmd),
+    );
+  });
+  if (commandList.length > 0) {
+    output = output.concat([
+      chalk.dim.bold('Commands'),
+      formatList(commandList),
+      '',
+    ]);
+  }
+
+  if (this.showGlobalOptions) {
+    const globalOptionList = visibleGlobalOptions.map((option) => {
+      return formatItem(
+        helper.optionTerm(option),
+        helper.optionDescription(option),
+      );
+    });
+    if (globalOptionList.length > 0) {
+      output = output.concat([
+        chalk.dim.bold('Global Options'),
+        formatList(globalOptionList),
+        '',
+      ]);
+    }
+  }
+
+  return output.join('\n');
+}
+
+program.configureHelp({
+  showGlobalOptions: true,
+  formatHelp,
+});
+
+program.parse(process.argv);