instant-cli 0.22.116-experimental.drewh-tanstack-start.21487748189.1 → 0.22.116-experimental.drewh-clief.21487748784.1

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

package/src/new/layer.ts

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

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

@@ -0,0 +1,107 @@
+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}`;
+}

package/src/new/lib/http.ts

@@ -0,0 +1,63 @@
+import { HttpClient, HttpClientRequest } from '@effect/platform';
+import { Config, Context, Effect, Layer, Option } from 'effect';
+import { AuthToken } from '../context/authToken.js';
+
+export class InstantHttp extends Context.Tag(
+  'instant-cli/new/lib/http/InstantHttp',
+)<InstantHttp, HttpClient.HttpClient>() {}
+
+export class InstantHttpAuthed extends Context.Tag(
+  'instant-cli/new/lib/http/InstantHttpAuthed',
+)<InstantHttpAuthed, HttpClient.HttpClient>() {}
+
+export const InstantHttpLive = Layer.effect(
+  InstantHttp,
+  Effect.gen(function* () {
+    const client = yield* HttpClient.HttpClient;
+    const baseUrl = yield* getBaseUrl;
+    return client.pipe(
+      HttpClient.mapRequest((r) =>
+        r.pipe(HttpClientRequest.prependUrl(baseUrl)),
+      ),
+      HttpClient.filterStatusOk, // makes non 2xx http codes error
+    );
+  }),
+);
+
+export const InstantHttpAuthedLive = Layer.effect(
+  InstantHttpAuthed,
+  Effect.gen(function* () {
+    const http = yield* InstantHttp;
+    const { authToken } = yield* AuthToken;
+    return http.pipe(
+      HttpClient.mapRequest((r) =>
+        r.pipe(
+          HttpClientRequest.setHeader('Authorization', `Bearer ${authToken}`),
+        ),
+      ),
+    );
+  }),
+);
+
+export const getBaseUrl = Effect.gen(function* () {
+  const setEnv = yield* Config.string('INSTANT_CLI_API_URI').pipe(
+    Config.option,
+  );
+  const dev = yield* Config.boolean('INSTANT_CLI_DEV').pipe(
+    Config.withDefault(false),
+  );
+
+  return Option.match(setEnv, {
+    onSome: (url) => url,
+    onNone: () => {
+      return dev ? 'http://localhost:8888' : 'https://api.instantdb.com';
+    },
+  });
+});
+
+export const getDashUrl = Effect.gen(function* () {
+  const dev = Option.getOrNull(
+    yield* Config.boolean('INSTANT_CLI_DEV').pipe(Config.option),
+  );
+  return dev ? 'http://localhost:3000' : 'https://instantdb.com';
+});

package/src/new/lib/login.ts

@@ -0,0 +1,50 @@
+import { Effect, Schedule, Schema } from 'effect';
+import { InstantHttp } from './http.js';
+import {
+  HttpClientRequest,
+  HttpClientResponse,
+  FileSystem,
+} from '@effect/platform';
+import { getAuthPaths } from '../../util/getAuthPaths.js';
+
+const LoginInfo = Schema.Struct({
+  secret: Schema.String,
+  ticket: Schema.String,
+});
+
+const TokenResult = Schema.Struct({
+  token: Schema.String,
+  email: Schema.String,
+});
+
+export const getLoginTicketAndSecret = Effect.gen(function* () {
+  const http = yield* InstantHttp;
+  const res = yield* http
+    .post('/dash/cli/auth/register')
+    .pipe(Effect.flatMap(HttpClientResponse.schemaBodyJson(LoginInfo)));
+  return res;
+});
+
+export const waitForAuthToken = Effect.fn(function* (secret: string) {
+  const http = yield* InstantHttp;
+  const res = yield* HttpClientRequest.post('/dash/cli/auth/check').pipe(
+    HttpClientRequest.bodyJson({
+      secret,
+    }),
+    Effect.flatMap(http.execute),
+    Effect.flatMap(HttpClientResponse.schemaBodyJson(TokenResult)),
+    Effect.retry({
+      schedule: Schedule.fixed('1 seconds'),
+      times: 12,
+    }),
+  );
+  return res;
+});
+
+export const saveConfigAuthToken = Effect.fn(function* (token: string) {
+  const authPaths = getAuthPaths();
+
+  const fs = yield* FileSystem.FileSystem;
+  yield* fs.makeDirectory(authPaths.appConfigDirPath, { recursive: true });
+  yield* fs.writeFileString(authPaths.authConfigFilePath, token);
+});

package/src/new/lib/ui.ts

@@ -0,0 +1,45 @@
+import { Data, Effect } from 'effect';
+import { GlobalOpts } from '../context/globalOpts.js';
+import { Prompt, renderUnwrap } from '../../ui/lib.js';
+import boxen from 'boxen';
+import { UI } from '../../ui/index.js';
+
+export class UIError extends Data.TaggedError('UIError')<{
+  message: string;
+  cause?: unknown;
+}> {}
+
+export const promptOk = Effect.fn('promptOk')(function* (
+  props: UI.ConfirmationProps,
+  defaultValue: boolean = true,
+) {
+  const opts = yield* GlobalOpts;
+  if (opts.yes) {
+    return defaultValue;
+  }
+
+  const ok = yield* Effect.tryPromise(() =>
+    renderUnwrap(
+      new UI.Confirmation({
+        ...props,
+        modifyOutput: (out) =>
+          boxen(out, {
+            dimBorder: true,
+            padding: {
+              left: 1,
+              right: 1,
+            },
+          }),
+        defaultValue,
+      }),
+    ),
+  ).pipe(Effect.orElseSucceed(() => defaultValue));
+
+  return ok;
+});
+
+export const runUIEffect = <P>(prompt: Prompt<P>) =>
+  Effect.tryPromise({
+    try: () => renderUnwrap(prompt),
+    catch: (error) => new UIError({ message: 'UI Error', cause: error }),
+  });

package/src/new/logging.ts

@@ -0,0 +1,9 @@
+import chalk from 'chalk';
+
+export function warn(firstArg, ...rest) {
+  console.warn(chalk.yellow('[warning]') + ' ' + firstArg, ...rest);
+}
+
+export function error(firstArg, ...rest) {
+  console.error(chalk.red('[error]') + ' ' + firstArg, ...rest);
+}

package/src/ui/index.ts

@@ -842,7 +842,7 @@ ${inputDisplay}`;
     }
   }
 
-  interface AppSelectorApi {
+  export interface AppSelectorApi {
     getDash: () => { apps: App[]; orgs: Org[] };
     createEphemeralApp: (title: string) => Promise<{
       appId: string;

package/src/util/getAuthPaths.ts

@@ -2,6 +2,7 @@ import envPaths from 'env-paths';
 import { join } from 'path';
 
 const dev = Boolean(process.env.INSTANT_CLI_DEV);
+
 export function getAuthPaths() {
   const key = `instantdb-${dev ? 'dev' : 'prod'}`;
   const { config: appConfigDirPath } = envPaths(key);

package/tsconfig.json

@@ -5,9 +5,14 @@
     "rootDir": "src",
     "sourceMap": true,
     "skipLibCheck": true, // `unconfig` currently imports a broken type from `@antfu/utils`,
-    "strictNullChecks": true
+    "plugins": [
+      {
+        "name": "@effect/language-service",
+      },
+    ],
+    "strictNullChecks": true,
     // remove once fixed
   },
   "include": ["src"],
-  "exclude": ["node_modules", "dist"]
+  "exclude": ["node_modules", "dist"],
 }