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

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"],
 }