instant-cli 0.22.177 → 0.22.178

package/src/lib/handleEnv.ts

@@ -0,0 +1,115 @@
+import { Effect } from 'effect';
+import { potentialEnvs } from '../context/currentApp.ts';
+import type { CurrentAppInfo } from '../context/currentApp.ts';
+import { ProjectInfo, ProjectInfoError } from '../context/projectInfo.ts';
+import { readPackage } from 'pkg-types';
+import { GlobalOpts } from '../context/globalOpts.ts';
+import { FileSystem, Path } from '@effect/platform';
+import chalk from 'chalk';
+import terminalLink from 'terminal-link';
+import { getDashUrl } from './http.ts';
+import { promptOk } from './ui.ts';
+
+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);
+  }
+  yield* Effect.log(
+    `\nLooks like you don't have a ${chalk.green(`\`${envFile}\``)} file yet.`,
+  );
+  yield* Effect.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) {
+    yield* Effect.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') {
+    yield* Effect.log(`Created ${chalk.green(envFile)}!`);
+  } else {
+    yield* Effect.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';
+  }
+  if (pkgJson.dependencies?.['@types/bun']) {
+    return 'bun';
+  }
+  return 'catchall';
+}).pipe(Effect.catchTag('ProjectInfoError', () => Effect.succeed('catchall')));
+
+function printDotEnvInfo(
+  envType: keyof typeof potentialEnvs,
+  appId: string,
+  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: string, instantOrigin: string) {
+  return `${instantOrigin}/dash?s=main&t=home&app=${id}`;
+}

package/src/lib/http.ts

@@ -0,0 +1,148 @@
+import { HttpClient, HttpClientRequest } from '@effect/platform';
+import { version } from '@instantdb/version';
+import { Config, Context, Data, Effect, Layer, Option, Schema } from 'effect';
+import { AuthToken } from '../context/authToken.ts';
+import { TimeoutException } from 'effect/Cause';
+import { RequestError } from '@effect/platform/HttpClientError';
+
+export class InstantHttp extends Context.Tag(
+  'instant-cli/new/lib/http/InstantHttp',
+)<
+  InstantHttp,
+  HttpClient.HttpClient.With<InstantHttpError | TimeoutException | RequestError>
+>() {}
+
+export class InstantHttpAuthed extends Context.Tag(
+  'instant-cli/new/lib/http/InstantHttpAuthed',
+)<
+  InstantHttpAuthed,
+  HttpClient.HttpClient.With<InstantHttpError | TimeoutException | RequestError>
+>() {}
+
+export class InstantHttpError extends Data.TaggedError('InstantHttpError')<
+  {
+    methodAndUrl: string;
+  } & typeof InstantTypicalHttpErrorResponse.Type
+> {}
+
+// Pipe on an http client to set the command header
+export const withCommand = (command: string) => {
+  return (
+    client: HttpClient.HttpClient.With<
+      InstantHttpError | TimeoutException | RequestError
+    >,
+  ) =>
+    client.pipe(
+      HttpClient.mapRequest((r) =>
+        r.pipe(HttpClientRequest.setHeader(`X-Instant-Command`, command)),
+      ),
+    );
+};
+
+class InstantTypicalHttpErrorResponse extends Schema.Struct({
+  message: Schema.String,
+  type: Schema.String.pipe(Schema.optional),
+  hint: Schema.Record({ key: Schema.String, value: Schema.Any }).pipe(
+    Schema.optional,
+  ),
+}) {}
+
+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),
+          HttpClientRequest.setHeader('X-Instant-Source', 'instant-cli'),
+          HttpClientRequest.setHeader('X-Instant-Version', version),
+        ),
+      ),
+      HttpClient.transformResponse((r) => r.pipe(Effect.timeout('5 minutes'))),
+      HttpClient.filterStatusOk, // makes non 2xx http codes error
+      // parses the non 2xx errors into known instant error shape
+      HttpClient.transformResponse((r) =>
+        r.pipe(
+          Effect.catchTag('ResponseError', (requestError) =>
+            Effect.gen(function* () {
+              const jsonBody = yield* requestError.response.json.pipe(
+                Effect.andThen(
+                  Schema.decodeUnknown(InstantTypicalHttpErrorResponse),
+                ),
+                Effect.mapError(
+                  (e) =>
+                    new InstantHttpError({
+                      message:
+                        'Error making request to ' + requestError.methodAndUrl,
+                      type: e._tag,
+                      methodAndUrl: requestError.methodAndUrl,
+                    }),
+                ),
+              );
+
+              // The hint.message is usually better error message
+              let message = jsonBody.message;
+              if (
+                jsonBody.hint?.message &&
+                typeof jsonBody.hint.message === 'string'
+              ) {
+                message = jsonBody.hint.message;
+              }
+
+              return yield* new InstantHttpError({
+                message: message,
+                methodAndUrl: requestError.methodAndUrl,
+                hint: jsonBody.hint,
+                type: jsonBody.type || 'Unknown type',
+              });
+            }),
+          ),
+        ),
+      ),
+    );
+  }),
+);
+
+export const InstantHttpAuthedLive = Layer.effect(
+  InstantHttpAuthed,
+  Effect.gen(function* () {
+    const http = yield* InstantHttp;
+    const authToken = yield* AuthToken;
+    return http.pipe(
+      HttpClient.mapRequestEffect((r) =>
+        authToken.getAuthToken.pipe(
+          Effect.map((token) =>
+            r.pipe(
+              HttpClientRequest.setHeader('Authorization', `Bearer ${token}`),
+            ),
+          ),
+        ),
+      ),
+    );
+  }),
+);
+
+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/lib/login.ts

@@ -0,0 +1,54 @@
+import { Effect, Schedule, Schema } from 'effect';
+import { InstantHttp, withCommand } from './http.ts';
+import {
+  HttpClientRequest,
+  HttpClientResponse,
+  FileSystem,
+} from '@effect/platform';
+import { getAuthPaths } from '../util/getAuthPaths.ts';
+
+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
+    .pipe(withCommand('login'))
+    .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).pipe(withCommand('login'));
+  const res = yield* HttpClientRequest.post('/dash/cli/auth/check').pipe(
+    HttpClientRequest.bodyUnsafeJson({
+      secret,
+    }),
+    http.execute,
+    Effect.flatMap(HttpClientResponse.schemaBodyJson(TokenResult)),
+    Effect.retry({
+      while: (e) =>
+        e._tag === 'InstantHttpError' &&
+        e.hint?.errors?.at(0)?.issue === 'waiting-for-user',
+      schedule: Schedule.fixed('1 seconds'),
+      times: 120,
+    }),
+  );
+  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/lib/pullPerms.ts

@@ -0,0 +1,50 @@
+import { Effect, Option, Schema } from 'effect';
+import { CurrentApp } from '../context/currentApp.ts';
+import { InstantHttpAuthed, withCommand } from './http.ts';
+import { HttpClientResponse } from '@effect/platform';
+import { readLocalPermsFile } from '../old.js';
+import { getPermsPathToWrite } from '../util/findConfigCandidates.ts';
+import { promptOk } from './ui.ts';
+import { UI } from '../ui/index.ts';
+import { writeTypescript } from './pullSchema.ts';
+import { generatePermsTypescriptFile } from '@instantdb/platform';
+import { ProjectInfo } from '../context/projectInfo.ts';
+import { Path } from '@effect/platform';
+
+export const pullPerms = Effect.gen(function* () {
+  yield* Effect.log('\nPulling perms...');
+  const { appId } = yield* CurrentApp;
+  const http = yield* InstantHttpAuthed;
+  const permsResponse = yield* http
+    .pipe(withCommand('pull'))
+    .get(`/dash/apps/${appId}/perms/pull`)
+    .pipe(Effect.flatMap(HttpClientResponse.schemaBodyJson(Schema.Any))); // parse result body into "any"
+
+  const prevPermsFile = yield* Effect.tryPromise(readLocalPermsFile).pipe(
+    Effect.map(Option.fromNullable),
+  );
+
+  const shortPermsPath = Option.match(prevPermsFile, {
+    onSome: (file) => file.path,
+    onNone: () => getPermsPathToWrite(),
+  });
+
+  if (Option.isSome(prevPermsFile)) {
+    const shouldContinue = yield* promptOk({
+      promptText: `This will overwrite your local ${shortPermsPath} file, OK to proceed?`,
+      modifyOutput: UI.modifiers.yPadding,
+      inline: true,
+    });
+    if (!shouldContinue) return;
+  }
+  const { instantModuleName, pkgDir } = yield* ProjectInfo;
+  const fileContent = generatePermsTypescriptFile(
+    permsResponse?.perms || {},
+    instantModuleName,
+  );
+
+  const path = yield* Path.Path;
+
+  yield* writeTypescript(path.join(pkgDir, shortPermsPath), fileContent);
+  yield* Effect.log('✅ Wrote permissions to ' + shortPermsPath);
+});

package/src/lib/pullSchema.ts

@@ -0,0 +1,95 @@
+import { FileSystem, HttpClientResponse, Path } from '@effect/platform';
+import {
+  apiSchemaToInstantSchemaDef,
+  generateSchemaTypescriptFile,
+} from '@instantdb/platform';
+import { Effect, Schema } from 'effect';
+import prettier from 'prettier';
+import { countEntities, readLocalSchemaFile } from '../old.js';
+import { UI } from '../ui/index.ts';
+import { getSchemaPathToWrite } from '../util/findConfigCandidates.ts';
+import { CurrentApp } from '../context/currentApp.ts';
+import { ProjectInfo } from '../context/projectInfo.ts';
+import { InstantHttpAuthed, withCommand } from './http.ts';
+import { promptOk } from './ui.ts';
+import { ReadSchemaFileError } from './pushSchema.ts';
+import { mergeSchema, MergeSchemaError } from '../util/mergeSchema.ts';
+
+export const pullSchema = ({
+  experimentalTypePreservation,
+}: {
+  experimentalTypePreservation?: boolean;
+}) =>
+  Effect.gen(function* () {
+    yield* Effect.log('Pulling schema...');
+    const { appId } = yield* CurrentApp;
+    const http = yield* InstantHttpAuthed;
+
+    const schemaResponse = yield* http
+      .pipe(withCommand('pull'))
+      .get(`/dash/apps/${appId}/schema/pull`)
+      .pipe(Effect.flatMap(HttpClientResponse.schemaBodyJson(Schema.Any))); // parse result body into "any"
+
+    if (
+      !countEntities(schemaResponse.schema.refs) &&
+      !countEntities(schemaResponse.schema.blobs)
+    ) {
+      yield* Effect.log('Schema is empty. Skipping.');
+      return;
+    }
+
+    const prevSchemaFile = yield* Effect.tryPromise(readLocalSchemaFile).pipe(
+      Effect.mapError((err) =>
+        ReadSchemaFileError.make({
+          message: `Error reading local schema file: ${err}`,
+          cause: err,
+        }),
+      ),
+    );
+    const shortSchemaPath = getSchemaPathToWrite(prevSchemaFile?.path);
+    const path = yield* Path.Path;
+    const { pkgDir, instantModuleName } = yield* ProjectInfo;
+    const schemaPath = path.join(pkgDir, shortSchemaPath);
+
+    if (prevSchemaFile) {
+      const shouldContinue = yield* promptOk({
+        promptText: `This will overwrite your local ${shortSchemaPath} file, OK to proceed?`,
+        modifyOutput: UI.modifiers.yPadding,
+        inline: true,
+      });
+      if (!shouldContinue) return;
+    }
+
+    let newSchemaContent = generateSchemaTypescriptFile(
+      prevSchemaFile?.schema,
+      apiSchemaToInstantSchemaDef(schemaResponse.schema),
+      instantModuleName,
+    );
+
+    if (prevSchemaFile && experimentalTypePreservation) {
+      const fs = yield* FileSystem.FileSystem;
+      const oldSchemaContent = yield* fs.readFileString(prevSchemaFile.path);
+      newSchemaContent = yield* Effect.try(() =>
+        mergeSchema(oldSchemaContent, newSchemaContent),
+      ).pipe(
+        Effect.mapError((e) => new MergeSchemaError({ message: e.message })),
+      );
+    }
+    yield* writeTypescript(schemaPath, newSchemaContent);
+    yield* Effect.log('✅ Wrote schema to ' + shortSchemaPath);
+  });
+
+export const writeTypescript = (path: string, content: string) =>
+  Effect.gen(function* () {
+    const prettierConfig = yield* Effect.tryPromise(() =>
+      prettier.resolveConfig(path),
+    );
+    const formattedCode = yield* Effect.tryPromise(() =>
+      prettier.format(content, {
+        ...prettierConfig,
+        parser: 'typescript',
+      }),
+    );
+    const fs = yield* FileSystem.FileSystem;
+    yield* fs.writeFileString(path, formattedCode);
+  });

package/src/lib/pushPerms.ts

@@ -0,0 +1,80 @@
+import { Effect, Option, Schema } from 'effect';
+import jsonDiff from 'json-diff';
+import { readLocalPermsFile } from '../old.js';
+import { InstantHttpAuthed, withCommand } from './http.ts';
+import {
+  HttpClient,
+  HttpClientRequest,
+  HttpClientResponse,
+} from '@effect/platform';
+import { CurrentApp } from '../context/currentApp.ts';
+import { promptOk } from './ui.ts';
+import boxen from 'boxen';
+import chalk from 'chalk';
+
+export class NoPermsFileError extends Schema.TaggedError<NoPermsFileError>(
+  'NoPermsFileError',
+)('NoPermsFileError', {
+  message: Schema.String,
+}) {}
+
+const PullPermsResponse = Schema.Struct({
+  perms: Schema.Any.pipe(Schema.optional),
+});
+
+export const pushPerms = Effect.gen(function* () {
+  yield* Effect.log('Planning perms...');
+  const { appId } = yield* CurrentApp;
+  const http = yield* InstantHttpAuthed;
+
+  const permsFile = yield* Effect.tryPromise(readLocalPermsFile).pipe(
+    Effect.flatMap(Option.fromNullable),
+    Effect.mapError(() =>
+      NoPermsFileError.make({
+        message: `We couldn't find your ${chalk.yellow('`instant.perms.ts`')} file. Make sure it's in the root directory. (Hint: You can use an INSTANT_PERMS_FILE_PATH environment variable to specify it.)`,
+      }),
+    ),
+  );
+
+  const prodPerms = yield* http
+    .pipe(withCommand('push'))
+    .get(`/dash/apps/${appId}/perms/pull`)
+    .pipe(Effect.flatMap(HttpClientResponse.schemaBodyJson(PullPermsResponse))); // parse result body into "any"
+
+  const diffedStr = jsonDiff.diffString(
+    prodPerms.perms || {},
+    permsFile.perms || {},
+  );
+
+  if (!diffedStr.length) {
+    yield* Effect.log('No perms changes detected. Skipping.');
+    return;
+  }
+
+  const okPush = yield* promptOk({
+    promptText: 'Push these changes to your perms?',
+    modifyOutput: (output) => {
+      let both = diffedStr + '\n' + output;
+      return boxen(both, {
+        dimBorder: true,
+        padding: {
+          left: 1,
+          right: 1,
+        },
+      });
+    },
+  });
+  if (!okPush) return;
+
+  yield* http
+    .pipe(
+      withCommand('push'),
+      HttpClient.mapRequestInputEffect(
+        HttpClientRequest.bodyJson({ code: permsFile.perms }),
+      ),
+    )
+    .post(`/dash/apps/${appId}/rules`)
+    .pipe(Effect.flatMap(HttpClientResponse.schemaBodyJson(Schema.Any)));
+
+  yield* Effect.log(chalk.green('Permissions updated!'));
+});