instant-cli 0.22.177 → 0.22.178

package/src/commands/explorer.ts

@@ -0,0 +1,21 @@
+import { Effect } from 'effect';
+import openInBrowser from 'open';
+import { explorerDef } from '../index.ts';
+import type { OptsFromCommand } from '../index.ts';
+import { CurrentApp } from '../context/currentApp.ts';
+import { getDashUrl } from '../lib/http.ts';
+
+export const explorerCmd = (_opts: OptsFromCommand<typeof explorerDef>) =>
+  Effect.gen(function* () {
+    const { appId } = yield* CurrentApp;
+    const dashUrl = yield* getDashUrl;
+    yield* Effect.log('Opening Explorer...');
+    const url = `${dashUrl}/dash?s=main&app=${appId}&t=explorer`;
+    yield* Effect.tryPromise(() => openInBrowser(url)).pipe(
+      Effect.catchAll(() =>
+        Effect.log(
+          `Failed to open Explorer in browser\nOpen Explorer manually:\n${url}`,
+        ),
+      ),
+    );
+  });

package/src/commands/info.ts

@@ -0,0 +1,34 @@
+import { HttpClientResponse } from '@effect/platform';
+import { Effect, Schema, Option } from 'effect';
+import { InstantHttpAuthed } from '../lib/http.ts';
+import { version } from '@instantdb/version';
+
+const DashMeResponse = Schema.Struct({
+  user: Schema.Struct({
+    id: Schema.String,
+    email: Schema.String,
+    created_at: Schema.String,
+  }),
+});
+
+export const infoCommand = () =>
+  Effect.gen(function* () {
+    const authedHttp = yield* Effect.serviceOption(InstantHttpAuthed).pipe(
+      Effect.map(Option.getOrNull),
+    );
+
+    yield* Effect.log('CLI Version:', version);
+    // If logged in..
+    if (authedHttp) {
+      const meData = yield* authedHttp.get('/dash/me').pipe(
+        Effect.flatMap(HttpClientResponse.schemaBodyJson(DashMeResponse)),
+        Effect.mapError(
+          (e) => new Error("Couldn't get user information.", { cause: e }),
+        ),
+      );
+
+      yield* Effect.log(`Logged in as ${meData.user.email}`);
+    } else {
+      yield* Effect.log('Not logged in.');
+    }
+  });

package/src/commands/init.ts

@@ -0,0 +1,58 @@
+import { Effect, Option } from 'effect';
+import { initDef } from '../index.ts';
+import type { OptsFromCommand } from '../index.ts';
+import { readLocalPermsFile, readLocalSchemaFile } from '../old.js';
+import { pullSchema } from '../lib/pullSchema.ts';
+import { pullPerms } from '../lib/pullPerms.ts';
+import { promptOk } from '../lib/ui.ts';
+import { pushSchema } from '../lib/pushSchema.ts';
+import { pushPerms } from '../lib/pushPerms.ts';
+
+export const initCommand = (_options: OptsFromCommand<typeof initDef>) =>
+  Effect.gen(function* () {
+    yield* Effect.matchEffect(
+      Effect.tryPromise(readLocalSchemaFile).pipe(
+        // Throws NoSuchElementException if no file found
+        Effect.flatMap(Option.fromNullable),
+      ),
+      {
+        onFailure: () => pullSchema({ experimentalTypePreservation: false }),
+        onSuccess: () =>
+          Effect.gen(function* () {
+            const doSchemaPush = yield* promptOk(
+              {
+                promptText: 'Found local schema. Push it to the new app?',
+                inline: true,
+              },
+              true,
+            );
+            if (doSchemaPush) {
+              yield* pushSchema();
+            }
+          }),
+      },
+    );
+
+    yield* Effect.matchEffect(
+      Effect.tryPromise(readLocalPermsFile).pipe(
+        // Throws NoSuchElementException if no file found
+        Effect.flatMap(Option.fromNullable),
+      ),
+      {
+        onFailure: () => pullPerms,
+        onSuccess: () =>
+          Effect.gen(function* () {
+            const doPermsPush = yield* promptOk(
+              {
+                promptText: 'Found local perms. Push it to the new app?',
+                inline: true,
+              },
+              true,
+            );
+            if (doPermsPush) {
+              yield* pushPerms;
+            }
+          }),
+      },
+    );
+  });

package/src/commands/initWithoutFiles.ts

@@ -0,0 +1,107 @@
+import { Effect } from 'effect';
+import { PlatformApi } from '../context/platformApi.ts';
+import { BadArgsError } from '../errors.ts';
+import { initWithoutFilesDef } from '../index.ts';
+import type { OptsFromCommand } from '../index.ts';
+import { createApp } from '../lib/createApp.ts';
+import { AuthLayerLive } from '../layer.ts';
+import chalk from 'chalk';
+import { NotAuthedError } from '../context/authToken.ts';
+
+export const initWithoutFilesCommand = (
+  opts: OptsFromCommand<typeof initWithoutFilesDef>,
+) =>
+  Effect.gen(function* () {
+    if (!opts?.title) {
+      return yield* BadArgsError.make({
+        message:
+          'Title is required for creating a new app without local files.',
+      });
+    }
+
+    if (opts.title.startsWith('-')) {
+      return yield* BadArgsError.make({
+        message: `Invalid title: "${opts.title}". Title cannot be a flag.`,
+      });
+    }
+
+    if (opts?.temp && opts?.orgId) {
+      return yield* BadArgsError.make({
+        message: 'Cannot use --temp and --org-id flags together.',
+      });
+    }
+
+    if (opts.temp) {
+      const platform = yield* PlatformApi;
+      const app = yield* platform.use((api) =>
+        api.createTemporaryApp({
+          title: opts.title!,
+        }),
+      );
+
+      console.error(`${chalk.green('Successfully created new app!')}\n`);
+      yield* Effect.log(
+        JSON.stringify(
+          {
+            app: {
+              appId: app.app.id,
+              adminToken: app.app.adminToken,
+            },
+            error: null,
+          },
+          null,
+          2,
+        ),
+      );
+
+      return;
+    }
+
+    const app = yield* createApp(opts.title, opts.orgId).pipe(
+      Effect.provide(
+        AuthLayerLive({
+          allowAdminToken: false,
+          coerce: false,
+        }),
+      ),
+    );
+    // Using console.error so the output is part of error channel and not picked up by jq
+    console.error(`${chalk.green('Successfully created new app!')}\n`);
+    yield* Effect.log(
+      JSON.stringify(
+        {
+          app: {
+            appId: app.app.id,
+            adminToken: app.app['admin-token'],
+          },
+          error: null,
+        },
+        null,
+        2,
+      ),
+    );
+  }).pipe(
+    Effect.catchTag('NotAuthedError', (e) =>
+      NotAuthedError.make({
+        message:
+          'Please log in first with `instant-cli login` before running this command.',
+      }),
+    ),
+    Effect.catchAll((e) =>
+      Effect.gen(function* () {
+        yield* Effect.log(
+          JSON.stringify(
+            {
+              app: null,
+              error: {
+                message: e.message,
+              },
+            },
+            null,
+            2,
+          ),
+        );
+        process.exit(1);
+      }),
+    ),
+  );

package/src/commands/login.ts

@@ -0,0 +1,76 @@
+import chalk from 'chalk';
+import { Effect } from 'effect';
+import openInBrowser from 'open';
+import { loginDef } from '../index.ts';
+import type { OptsFromCommand } from '../index.ts';
+import { getDashUrl } from '../lib/http.ts';
+import {
+  getLoginTicketAndSecret,
+  saveConfigAuthToken,
+  waitForAuthToken,
+} from '../lib/login.ts';
+import { promptOk } from '../lib/ui.ts';
+
+const isHeadLessEnvironment = (opts: OptsFromCommand<typeof loginDef>) => {
+  const noBrowserMode = Boolean(
+    process.env.INSTANT_CLI_NO_BROWSER || process.env.CI || opts?.headless,
+  );
+
+  // Check for common headless environment indicators
+  return (
+    noBrowserMode ||
+    process.env.TERM === 'dumb' ||
+    process.env.SSH_CONNECTION !== undefined ||
+    process.env.SSH_CLIENT !== undefined ||
+    (!process.env.DISPLAY && process.platform === 'linux') ||
+    process.env.WSL_DISTRO_NAME !== undefined
+  );
+};
+
+export const loginCommand = Effect.fn(function* (
+  opts: OptsFromCommand<typeof loginDef>,
+) {
+  yield* Effect.log("Let's log you in!");
+
+  const loginInfo = yield* getLoginTicketAndSecret;
+  const { secret, ticket } = loginInfo;
+  const dashOrigin = yield* getDashUrl;
+  yield* Effect.log();
+  // TODO: flip these so rejecting the prompt prints url
+  if (isHeadLessEnvironment(opts)) {
+    yield* Effect.log(
+      `Open this URL in a browser to log in:\n ${dashOrigin}/dash?ticket=${ticket}\n`,
+    );
+  } else {
+    const ok = yield* promptOk(
+      {
+        promptText:
+          'This will open instantdb.com in your browser, OK to proceed?',
+      },
+      true,
+    );
+    if (!ok) {
+      process.exit(0);
+    }
+    yield* Effect.tryPromise(() =>
+      openInBrowser(`${dashOrigin}/dash?ticket=${ticket}`),
+    );
+  }
+
+  yield* Effect.log('Waiting for authentication...');
+
+  const result = yield* waitForAuthToken(secret);
+  const { token, email } = result;
+  if (opts.print) {
+    yield* Effect.log(
+      chalk.red('[Do not share] Your Instant auth token:', token),
+    );
+  } else {
+    yield* saveConfigAuthToken(token);
+    yield* Effect.log(chalk.green(`Successfully logged in as ${email}!`));
+  }
+  return {
+    authToken: token,
+    source: 'file' as const,
+  };
+});

package/src/commands/logout.ts

@@ -0,0 +1,23 @@
+import { Effect } from 'effect';
+import { getAuthPaths } from '../util/getAuthPaths.ts';
+import { FileSystem } from '@effect/platform';
+import chalk from 'chalk';
+import { SystemError } from '@effect/platform/Error';
+
+export const logoutCommand = Effect.fn(function* () {
+  const { authConfigFilePath } = getAuthPaths();
+  const fs = yield* FileSystem.FileSystem;
+
+  yield* Effect.matchEffect(fs.remove(authConfigFilePath), {
+    onFailure: (e) =>
+      Effect.gen(function* () {
+        if (e instanceof SystemError && e.reason === 'NotFound') {
+          yield* Effect.log(chalk.green('You were already logged out!'));
+        } else {
+          yield* Effect.logError(chalk.red('Failed to logout: ' + e.message));
+        }
+      }),
+    onSuccess: () =>
+      Effect.log(chalk.green('Successfully logged out from Instant!')),
+  });
+});

package/src/commands/pull.ts

@@ -0,0 +1,23 @@
+import { Effect } from 'effect';
+import { pullDef } from '../index.ts';
+import type { OptsFromCommand } from '../index.ts';
+import { pullSchema } from '../lib/pullSchema.ts';
+import { pullPerms } from '../lib/pullPerms.ts';
+
+export type SchemaPermsOrBoth = 'schema' | 'perms' | 'all';
+
+export const pullCommand = (
+  arg: SchemaPermsOrBoth,
+  opts: OptsFromCommand<typeof pullDef>,
+) =>
+  Effect.gen(function* () {
+    arg ||= 'all';
+    if (arg === 'schema' || arg === 'all') {
+      yield* pullSchema({
+        experimentalTypePreservation: opts.experimentalTypePreservation,
+      });
+    }
+    if (arg === 'perms' || arg === 'all') {
+      yield* pullPerms;
+    }
+  });

package/src/commands/push.ts

@@ -0,0 +1,25 @@
+import { Effect } from 'effect';
+import { BadArgsError } from '../errors.ts';
+import { pushDef } from '../index.ts';
+import type { OptsFromCommand } from '../index.ts';
+import { pushPerms } from '../lib/pushPerms.ts';
+import { pushSchema } from '../lib/pushSchema.ts';
+
+export const pushCommand = (
+  arg: string | undefined,
+  opts: OptsFromCommand<typeof pushDef>,
+) =>
+  Effect.gen(function* () {
+    arg ||= 'all';
+    if (arg !== 'schema' && arg !== 'perms' && arg !== 'all') {
+      return yield* new BadArgsError({
+        message: `Invalid argument: ${arg}. Expected one of schema, perms, or all`,
+      });
+    }
+    if (arg === 'schema' || arg === 'all') {
+      yield* pushSchema(opts.rename);
+    }
+    if (arg === 'perms' || arg === 'all') {
+      yield* pushPerms;
+    }
+  });

package/src/commands/query.ts

@@ -0,0 +1,61 @@
+import { Effect, Layer } from 'effect';
+import JSON5 from 'json5';
+import { queryDef } from '../index.ts';
+import type { OptsFromCommand } from '../index.ts';
+import { CurrentApp } from '../context/currentApp.ts';
+import { BadArgsError } from '../errors.ts';
+import { InstantHttpAuthed, withCommand } from '../lib/http.ts';
+import { HttpBody } from '@effect/platform';
+import { WithAppLayer } from '../layer.ts';
+
+export const queryCmd = (arg: string, opts: OptsFromCommand<typeof queryDef>) =>
+  Effect.gen(function* () {
+    const { appId } = yield* CurrentApp;
+    const contexts = [
+      opts.admin,
+      opts.asEmail,
+      opts.asGuest,
+      opts.asToken,
+    ].filter(Boolean);
+    if (contexts.length > 1) {
+      return yield* BadArgsError.make({
+        message:
+          'Please specify exactly one context: --admin, --as-email <email>, --as-guest, or --as-token <token>',
+      });
+    }
+
+    const query = yield* Effect.try({
+      try: () => JSON5.parse(arg),
+      catch: (e) =>
+        BadArgsError.make({
+          message: String(e),
+        }),
+    });
+
+    const headers: Record<string, string> = { 'app-id': appId };
+    if (opts.asEmail) {
+      headers['as-email'] = opts.asEmail;
+    } else if (opts.asGuest) {
+      headers['as-guest'] = 'true';
+    } else if (opts.asToken) {
+      headers['as-token'] = opts.asToken;
+    }
+
+    const http = (yield* InstantHttpAuthed).pipe(withCommand('query'));
+    const response = yield* http.post('/admin/query', {
+      headers,
+      body: HttpBody.unsafeJson({
+        query,
+        'inference?': true,
+      }),
+    });
+    const body = yield* response.json;
+    yield* Effect.log(JSON.stringify(body, null, 2));
+  }).pipe(
+    Effect.provide(
+      WithAppLayer({
+        coerce: false,
+        appId: opts.app,
+      }).pipe(Layer.annotateLogs('silent', true)),
+    ),
+  );

package/src/context/authToken.ts

@@ -0,0 +1,149 @@
+import { FileSystem } from '@effect/platform';
+import { Config, Context, Effect, Layer, Option, Ref, Schema } from 'effect';
+import envPaths from 'env-paths';
+import { join } from 'path';
+import { loginCommand } from '../commands/login.ts';
+import { program } from '../program.ts';
+
+type AuthTokenSource = 'admin' | 'env' | 'opt' | 'file';
+
+type AuthTokenState = {
+  authToken: string;
+  source: AuthTokenSource;
+};
+
+export class AuthToken extends Context.Tag('instant-cli/new/context/authToken')<
+  AuthToken,
+  {
+    getAuthToken: Effect.Effect<string>;
+    getSource: Effect.Effect<AuthTokenSource>;
+    setAuthToken: (
+      authToken: string,
+      source?: AuthTokenSource,
+    ) => Effect.Effect<void>;
+  }
+>() {}
+
+export class NotAuthedError extends Schema.TaggedError<NotAuthedError>(
+  'NotAuthedError',
+)('NotAuthedError', {
+  message: Schema.String,
+}) {}
+
+export const authTokenGetEffect = (allowAdminToken: boolean = true) =>
+  Effect.gen(function* () {
+    const options = program.opts() as Record<string, any>;
+    if (typeof options.token === 'string') {
+      return {
+        authToken: options.token,
+        source: 'opt' as 'env' | 'opt' | 'file',
+      };
+    }
+
+    const env = yield* Config.string('INSTANT_CLI_AUTH_TOKEN').pipe(
+      Config.option,
+      Config.map(Option.getOrNull),
+    );
+
+    if (env) {
+      return {
+        authToken: env,
+        source: 'env' as 'env' | 'opt' | 'file',
+      };
+    }
+
+    const secondaryEnv = yield* Config.string('INSTANT_APP_ADMIN_TOKEN').pipe(
+      Config.orElse(() => Config.string('INSTANT_ADMIN_TOKEN')),
+      Config.option,
+      Config.map(Option.getOrNull),
+    );
+    if (secondaryEnv && allowAdminToken) {
+      return {
+        authToken: secondaryEnv,
+        source: 'admin' as 'admin',
+      };
+    }
+
+    const authPaths = yield* getAuthPaths;
+    const fs = yield* FileSystem.FileSystem;
+    const file = yield* fs
+      .readFileString(authPaths.authConfigFilePath, 'utf8')
+      .pipe(
+        // will usually fail if file not found, return null instead
+        Effect.orElseSucceed(() => null),
+      );
+    if (file) {
+      return {
+        authToken: file,
+        source: 'file' as 'env' | 'opt' | 'file',
+      };
+    }
+
+    return yield* NotAuthedError.make({ message: 'You are not logged in' });
+  });
+
+export const AuthTokenLive = ({
+  coerce,
+  allowAdminToken = true,
+}: {
+  coerce: boolean;
+  allowAdminToken: boolean;
+}) =>
+  Layer.effect(
+    AuthToken,
+    authTokenGetEffect(allowAdminToken).pipe(
+      Effect.flatMap((tokenResult) =>
+        Effect.gen(function* () {
+          const authStateRef = yield* Ref.make<AuthTokenState>(tokenResult);
+          return {
+            getAuthToken: Ref.get(authStateRef).pipe(
+              Effect.map((authState) => authState.authToken),
+            ),
+            getSource: Ref.get(authStateRef).pipe(
+              Effect.map((authState) => authState.source),
+            ),
+            setAuthToken: (authToken: string, source?: AuthTokenSource) =>
+              Ref.update(authStateRef, (authState) => ({
+                ...authState,
+                authToken,
+                source: source ?? authState.source,
+              })),
+          };
+        }),
+      ),
+      Effect.catchTag('NotAuthedError', (e) =>
+        Effect.gen(function* () {
+          if (coerce) {
+            const loginResult = yield* loginCommand({});
+            const authStateRef = yield* Ref.make<AuthTokenState>(loginResult);
+            return {
+              getAuthToken: Ref.get(authStateRef).pipe(
+                Effect.map((authState) => authState.authToken),
+              ),
+              getSource: Ref.get(authStateRef).pipe(
+                Effect.map((authState) => authState.source),
+              ),
+              setAuthToken: (authToken: string, source?: AuthTokenSource) =>
+                Ref.update(authStateRef, (authState) => ({
+                  ...authState,
+                  authToken,
+                  source: source ?? authState.source,
+                })),
+            };
+          } else {
+            return yield* e;
+          }
+        }),
+      ),
+    ),
+  );
+
+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 };
+});