instant-cli 0.22.177 → 0.22.178

package/src/context/currentApp.ts

@@ -0,0 +1,277 @@
+import { HttpClientRequest, HttpClientResponse } from '@effect/platform';
+import { randomUUID } from 'crypto';
+import { Context, Data, Effect, Layer, Runtime, Schema, Option } from 'effect';
+import { UI } from '../ui/index.ts';
+import { handleEnv } from '../lib/handleEnv.ts';
+import { getBaseUrl, InstantHttpAuthed, withCommand } from '../lib/http.ts';
+import { runUIEffect } from '../lib/ui.ts';
+import { AuthToken } from './authToken.ts';
+import { GlobalOpts } from './globalOpts.ts';
+import { PlatformApi } from './platformApi.ts';
+import { readInstantConfigFile } from '../old.js';
+import { BadArgsError } from '../errors.ts';
+
+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: string) {
+  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',
+  bun: 'BUN_PUBLIC_INSTANT_APP_ID',
+};
+
+const potentialAdminTokenEnvs = {
+  default: 'INSTANT_APP_ADMIN_TOKEN',
+  short: 'INSTANT_ADMIN_TOKEN',
+} as const;
+
+// 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) {
+        if (isUUID(args.appId)) {
+          return {
+            appId: args.appId,
+            source: 'flag' as const,
+          };
+        } else {
+          // Check for instant.config.ts
+          const config = yield* Effect.tryPromise(() =>
+            readInstantConfigFile(),
+          );
+          if (!config) {
+            return yield* new BadArgsError({
+              message: `App ID provided (${args.appId}) is not valid UUID`,
+            });
+          }
+          const nameMatch = config?.apps?.[args.appId];
+          if (!nameMatch?.id) {
+            return yield* BadArgsError.make({
+              message: 'App ID not found in app inside instant.config.ts',
+            });
+          }
+          if (nameMatch) {
+            return {
+              appId: nameMatch.id,
+              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) {
+        // try to get admin token
+        const adminToken = yield* getAdminToken;
+        return {
+          adminToken: Option.getOrUndefined(adminToken),
+          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: `If you provide --yes, you must provide a --title flag.`,
+              });
+            } else {
+              yield* Effect.log(`Creating app with title: ${args.title}`);
+              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' ||
+              app.source == 'ephemeral')
+          ) {
+            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({
+      startingMenuIndex: 0,
+      allowEphemeral: true,
+      allowCreate: true,
+      api,
+    }),
+  );
+
+  if (result.approach === 'ephemeral') {
+    const authToken = yield* AuthToken;
+    yield* authToken.setAuthToken(result.adminToken, 'admin');
+  }
+
+  if (result.approach === 'import') {
+    yield* Effect.fork(trackAppImport(result.appId));
+  }
+
+  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 token = await Runtime.runPromise(
+        effectRuntime,
+        authToken.getAuthToken,
+      );
+      const response = await fetch(baseUrl + '/dash/orgs/' + orgId, {
+        headers: {
+          Authorization: `Bearer ${token}`,
+        },
+      });
+      const data = await response.json();
+      return { apps: data.apps };
+    },
+  } satisfies UI.AppSelectorApi;
+});
+
+const getAdminToken = Effect.gen(function* () {
+  const found = Object.keys(potentialAdminTokenEnvs)
+    .map((type) => {
+      const envName =
+        potentialAdminTokenEnvs[type as keyof typeof potentialAdminTokenEnvs];
+      const value = process.env[envName];
+      return { type, envName, value };
+    })
+    .find(({ value }) => !!value);
+  return Option.fromNullable(found?.value);
+});
+
+const trackAppImport = (appId: string) =>
+  Effect.gen(function* () {
+    const http = (yield* InstantHttpAuthed).pipe(withCommand('init'));
+    yield* http.post(`/dash/apps/${appId}/track-import`);
+  });

package/src/context/globalOpts.ts

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

package/src/context/platformApi.ts

@@ -0,0 +1,35 @@
+import { PlatformApi as InstantPlatformApi } from '@instantdb/platform';
+import { Data, Effect } from 'effect';
+import { getBaseUrl } from '../lib/http.ts';
+
+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/context/projectInfo.ts

@@ -0,0 +1,215 @@
+import { Context, Data, Effect, Layer } from 'effect';
+import { detect } from 'package-manager-detector/detect';
+import { readPackage } from 'pkg-types';
+import type { PackageJson } from 'pkg-types';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { UI } from '../ui/index.ts';
+import { findProjectDir } from '../util/projectDir.ts';
+import { runUIEffect } from '../lib/ui.ts';
+import chalk from 'chalk';
+import { GlobalOpts } from './globalOpts.ts';
+import { BadArgsError } from '../errors.ts';
+
+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',
+  solid: '@instantdb/solidjs',
+  svelte: '@instantdb/svelte',
+};
+
+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). Is there a package.json or deno.json file?",
+      });
+    }
+
+    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:
+            "We couldn't find an Instant SDK. Install one, or run `init`",
+        }),
+    });
+
+    yield* Effect.log('Checking for an Instant SDK...');
+    let moduleName = getInstantModuleName(pkgJson);
+    if (!moduleName && !coerce) {
+      return yield* new ProjectInfoError({
+        message: "We couldn't find an Instant SDK. Install one, or run `init`",
+      });
+    }
+
+    if (!moduleName && coerce) {
+      yield* Effect.log(
+        "Couldn't find an Instant SDK in your package.json, let's install one!",
+      );
+    } else {
+      yield* Effect.log(
+        `Found ${chalk.green(moduleName)} in your package.json.\n`,
+      );
+    }
+
+    // TODO: Clean up with option
+    const packageManager = yield* Effect.tryPromise(() => detect()).pipe(
+      Effect.flatMap(Effect.fromNullable),
+      Effect.catchTag('NoSuchElementException', () =>
+        Effect.succeed({
+          name: 'npm',
+          agent: 'npm',
+        }),
+      ),
+      Effect.option,
+    );
+
+    const { yes } = yield* GlobalOpts;
+    if (!moduleName && coerce) {
+      // install the packages
+      if (packageName) {
+        moduleName = PACKAGE_ALIAS_AND_FULL_NAMES[packageName];
+      } else {
+        if (yes) {
+          return yield* BadArgsError.make({
+            message:
+              '--yes was provided without a package specification and no Instant SDK was found',
+          });
+        }
+        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' },
+              { label: '@instantdb/solidjs', value: '@instantdb/solidjs' },
+              { label: '@instantdb/svelte', value: '@instantdb/svelte' },
+            ],
+          }),
+        ).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 pkgManager = yield* packageManager.pipe(
+        Effect.mapError(
+          (e) =>
+            new ProjectInfoError({
+              message: 'Failed to detect package manager',
+              cause: e,
+            }),
+        ),
+      );
+
+      const installCommand = getInstallCommand(
+        pkgManager.agent,
+        packagesToInstall.join(' '),
+      );
+      yield* Effect.log(installCommand);
+      yield* runUIEffect(
+        new UI.Spinner({
+          promise: execAsync(installCommand, {
+            cwd: projectDir.dir,
+          }),
+          errorText: 'Failed to install packages',
+          workingText: `Installing ${packagesToInstall.join(', ')} using ${pkgManager.agent}...`,
+          doneText: `Installed ${packagesToInstall.join(', ')} using ${pkgManager.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',
+    '@instantdb/solidjs',
+    '@instantdb/svelte',
+  ].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/errors.ts

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