instant-cli 0.22.118-experimental.drewh-cia-errors.21490787265.1 → 0.22.118-experimental.drewh-clief.21490953381.1

package/src/new/context/authToken.ts

@@ -0,0 +1,77 @@
+import { FileSystem } from '@effect/platform';
+import { program } from 'commander';
+import { Config, Context, Effect, Layer, Option, Schema } from 'effect';
+import envPaths from 'env-paths';
+import { join } from 'path';
+import { loginCommand } from '../commands/login.js';
+
+export class AuthToken extends Context.Tag('instant-cli/new/context/authToken')<
+  AuthToken,
+  {
+    authToken: string;
+    source: 'env' | 'opt' | 'file';
+  }
+>() {}
+
+export class NotAuthedError extends Schema.TaggedError<NotAuthedError>(
+  'NotAuthedError',
+)('NotAuthedError', {
+  message: Schema.String,
+}) {}
+
+const authTokenGetEffect = Effect.gen(function* () {
+  const options = program.opts();
+  if (typeof options.token === 'string') {
+    return {
+      authToken: options.token,
+      source: 'opt' as 'env' | 'opt' | 'file',
+    };
+  }
+
+  const env = Option.getOrNull(
+    yield* Config.string('INSTANT_CLI_AUTH_TOKEN').pipe(Config.option),
+  );
+  if (env) {
+    return {
+      authToken: env,
+      source: 'env' as 'env' | 'opt' | 'file',
+    };
+  }
+
+  const authPaths = yield* getAuthPaths;
+  const fs = yield* FileSystem.FileSystem;
+  const file = yield* fs.readFileString(authPaths.authConfigFilePath, 'utf8');
+
+  if (file) {
+    return {
+      authToken: file,
+      source: 'file' as 'env' | 'opt' | 'file',
+    };
+  }
+
+  return yield* NotAuthedError.make({ message: 'You are not logged in' });
+});
+
+export const AuthTokenLive = Layer.effect(AuthToken, authTokenGetEffect);
+
+export const AuthTokenCoerceLive = Layer.effect(
+  AuthToken,
+  authTokenGetEffect.pipe(
+    Effect.catchTag('NotAuthedError', () =>
+      loginCommand({
+        print: true,
+        headless: true,
+      }),
+    ),
+  ),
+);
+
+const getAuthPaths = Effect.gen(function* () {
+  const dev = yield* Config.boolean('INSTANT_CLI_DEV').pipe(
+    Config.withDefault(false),
+  );
+  const key = `instantdb-${dev ? 'dev' : 'prod'}`;
+  const { config: appConfigDirPath } = envPaths(key);
+  const authConfigFilePath = join(appConfigDirPath, 'a');
+  return { authConfigFilePath, appConfigDirPath };
+});

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,
+}) {}