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

package/src/new/context/platformApi.ts

@@ -1,35 +0,0 @@
-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

@@ -1,172 +0,0 @@
-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

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

package/src/new/index.ts

@@ -1,245 +0,0 @@
-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);

package/src/new/layer.ts

@@ -1,78 +0,0 @@
-import { NodeContext, NodeHttpClient } from '@effect/platform-node';
-import chalk from 'chalk';
-import { Cause, Console, Effect, Layer } from 'effect';
-import { InstantHttpAuthedLive, InstantHttpLive } from './lib/http.js';
-import { AuthTokenLive } from './context/authToken.js';
-import { PlatformApi } from './context/platformApi.js';
-import { GlobalOptsLive } from './context/globalOpts.js';
-import {
-  PACKAGE_ALIAS_AND_FULL_NAMES,
-  ProjectInfoLive,
-} from './context/projectInfo.js';
-import { CurrentAppLive } from './context/currentApp.js';
-
-export const printRedErrors = Effect.catchAllCause((cause) => {
-  const failure = Cause.failureOption(cause);
-
-  // Print just the message if the error has a message attribute and no cause
-  if (
-    failure._tag === 'Some' &&
-    typeof failure.value === 'object' &&
-    failure.value !== null &&
-    'message' in failure.value &&
-    !('cause' in failure.value)
-  ) {
-    return Console.error(
-      chalk.red((failure.value as { message: string }).message),
-    );
-  }
-  return Console.error(
-    chalk.red(Cause.pretty(cause, { renderErrorCause: true })),
-  );
-});
-
-/**
- * Note:
- Avoid Duplicate Layer Creation
-
- Layers are memoized using reference equality. Therefore, if you have a layer that is created by calling a function like f(), you should only call that f once and re-use the resulting layer so that you are always using the same instance.
- */
-
-// Base layers
-const AuthTokenLayer = Layer.provide(AuthTokenLive, NodeContext.layer);
-const InstantHttpLayer = Layer.provide(InstantHttpLive, NodeHttpClient.layer);
-
-// Unauthenticated layer with InstantHttp + PlatformApi + GlobalOpts + NodeContext
-export const BaseLayerLive = Layer.provideMerge(
-  Layer.mergeAll(InstantHttpLayer, PlatformApi.Default, GlobalOptsLive),
-  NodeContext.layer,
-);
-
-// Authenticated layer extends BaseLayerLive with InstantHttpAuthed
-export const AuthLayerLive = Layer.provideMerge(
-  Layer.provideMerge(
-    InstantHttpAuthedLive,
-    Layer.merge(AuthTokenLayer, InstantHttpLayer),
-  ),
-  BaseLayerLive,
-);
-
-export const WithAppLayer = (args: {
-  appId?: string;
-  title?: string;
-  coerce: boolean;
-  packageName: keyof typeof PACKAGE_ALIAS_AND_FULL_NAMES;
-  applyEnv?: boolean;
-}) =>
-  Layer.mergeAll(
-    CurrentAppLive({
-      coerce: args.coerce,
-      appId: args.appId,
-      title: args.title,
-      applyEnv: args.applyEnv,
-    }),
-  ).pipe(
-    Layer.provideMerge(GlobalOptsLive),
-    Layer.provideMerge(AuthLayerLive),
-    Layer.provideMerge(ProjectInfoLive(args.coerce, args.packageName)),
-  );

package/src/new/lib/createApp.ts

@@ -1,18 +0,0 @@
-import { randomUUID } from 'crypto';
-import { Effect } from 'effect';
-import { InstantHttpAuthed } from './http.js';
-import { HttpClientRequest } from '@effect/platform';
-
-export const createApp = Effect.fn(function* (title: string, orgId?: string) {
-  const http = yield* InstantHttpAuthed;
-  const id = randomUUID();
-  const token = randomUUID();
-  const app = { id, title, admin_token: token, org_id: orgId };
-
-  const res = yield* HttpClientRequest.post('/dash/apps').pipe(
-    HttpClientRequest.bodyJson(app),
-    Effect.flatMap(http.execute),
-    Effect.flatMap((res) => res.json),
-  );
-  return res;
-});

package/src/new/lib/handleEnv.ts

@@ -1,107 +0,0 @@
-import { Effect } from 'effect';
-import { CurrentAppInfo, potentialEnvs } from '../context/currentApp.js';
-import { ProjectInfo, ProjectInfoError } from '../context/projectInfo.js';
-import { readPackage } from 'pkg-types';
-import { GlobalOpts } from '../context/globalOpts.js';
-import { FileSystem, Path } from '@effect/platform';
-import chalk from 'chalk';
-import terminalLink from 'terminal-link';
-import { getDashUrl } from './http.js';
-import { promptOk } from './ui.js';
-
-export const handleEnv = Effect.fn(function* (app: CurrentAppInfo) {
-  const opts = yield* GlobalOpts;
-  const { pkgDir } = yield* ProjectInfo;
-  const envType = yield* detectEnvType;
-  const envName = potentialEnvs[envType];
-  const envFile = opts.env ?? '.env';
-  const fs = yield* FileSystem.FileSystem;
-  const path = yield* Path.Path;
-  const hasEnvFile = yield* fs.exists(path.join(pkgDir, envFile));
-  const dashOrigin = yield* getDashUrl;
-  if (hasEnvFile) {
-    return printDotEnvInfo(envType, app.appId, dashOrigin);
-  }
-  console.log(
-    `\nLooks like you don't have a ${chalk.green(`\`${envFile}\``)} file yet.`,
-  );
-  console.log(
-    `If we set ${chalk.green(envName)} & ${chalk.green('INSTANT_APP_ADMIN_TOKEN')}, we can remember the app that you chose for all future commands.`,
-  );
-  const saveExtraInfo =
-    envFile !== '.env' ? chalk.green('  (will create `' + envFile + '`)') : '';
-
-  const ok = yield* promptOk(
-    {
-      inline: true,
-      promptText: 'Want us to create this env file for you?' + saveExtraInfo,
-      modifyOutput: (a) => a,
-    },
-    true,
-  );
-  if (!ok) {
-    console.log(
-      `No .env file created. You can always set ${chalk.green('`' + envName + '`')} later. \n`,
-    );
-    return;
-  }
-  const content =
-    [
-      [envName, app.appId],
-      ['INSTANT_APP_ADMIN_TOKEN', app.adminToken],
-    ]
-      .map(([k, v]) => `${k}=${v}`)
-      .join('\n') + '\n';
-
-  yield* fs.writeFileString(path.join(pkgDir, envFile), content);
-
-  if (envFile !== '.env') {
-    console.log(`Created ${chalk.green(envFile)}!`);
-  } else {
-    console.log(`Created ${chalk.green('.env')} file!`);
-  }
-});
-
-const detectEnvType = Effect.gen(function* () {
-  const pkgJson = yield* Effect.tryPromise({
-    try: () => readPackage(),
-    catch: () =>
-      new ProjectInfoError({ message: "Couldn't read package.json" }),
-  });
-  if (pkgJson.dependencies?.next) {
-    return 'next';
-  }
-  if (pkgJson.devDependencies?.svelte) {
-    return 'svelte';
-  }
-  if (pkgJson.devDependencies?.vite) {
-    return 'vite';
-  }
-  if (pkgJson.dependencies?.expo) {
-    return 'expo';
-  }
-  if (pkgJson.dependencies?.nuxt) {
-    return 'nuxt';
-  }
-  return 'catchall';
-}).pipe(Effect.catchTag('ProjectInfoError', () => Effect.succeed('catchall')));
-
-function printDotEnvInfo(envType, appId, dashOrigin: string) {
-  console.log(`\nPicked app ${chalk.green(appId)}!\n`);
-  console.log(
-    `To use this app automatically from now on, update your ${chalk.green('`.env`')} file:`,
-  );
-  const picked = potentialEnvs[envType];
-  const rest = { ...potentialEnvs };
-  delete rest[envType];
-  console.log(`  ${chalk.green(picked)}=${appId}`);
-  const otherEnvs = Object.values(rest);
-  otherEnvs.sort();
-  const otherEnvStr = otherEnvs.map((x) => '  ' + chalk.green(x)).join('\n');
-  console.log(`Alternative names: \n${otherEnvStr} \n`);
-  console.log(terminalLink('Dashboard:', appDashUrl(appId, dashOrigin)) + '\n');
-}
-
-function appDashUrl(id, instantOrigin: string) {
-  return `${instantOrigin}/dash?s=main&t=home&app=${id}`;
-}