instant-cli 0.22.155 → 0.22.156

package/.turbo/turbo-build.log

@@ -1,4 +1,4 @@
 
-> instant-cli@0.22.155 build /home/runner/work/instant/instant/client/packages/cli
+> instant-cli@0.22.156 build /home/runner/work/instant/instant/client/packages/cli
 > rm -rf dist; tsc -p tsconfig.json
 

package/__tests__/e2e/cli.e2e.test.ts

@@ -0,0 +1,551 @@
+import { describe, it, expect } from 'vitest';
+import { readFile } from 'fs/promises';
+import { join } from 'path';
+import { runCli, createTestProject, createTempApp } from './helpers';
+
+const SCHEMA_FILE = `
+import { i } from "@instantdb/core";
+
+const _schema = i.schema({
+  entities: {
+    posts: i.entity({
+      title: i.string(),
+      body: i.string(),
+    }),
+    comments: i.entity({
+      text: i.string(),
+    }),
+  },
+  links: {
+    postComments: {
+      forward: { on: "posts", has: "many", label: "comments" },
+      reverse: { on: "comments", has: "one", label: "post" },
+    },
+  },
+});
+
+export default _schema;
+`;
+
+const PERMS_FILE = `export default {
+  posts: { allow: { view: "true", create: "true" } },
+};
+`;
+
+describe.concurrent('CLI e2e', { timeout: 30_000 }, () => {
+  describe('init-without-files', () => {
+    it('creates a temp app and outputs JSON', async () => {
+      const result = await runCli([
+        'init-without-files',
+        '--title',
+        'e2e-temp-test',
+        '--temp',
+      ]);
+
+      expect(result.exitCode).toBe(0);
+
+      const jsonMatch = result.stdout.match(/\{[\s\S]*\}/);
+      expect(jsonMatch).toBeTruthy();
+
+      const parsed = JSON.parse(jsonMatch![0]);
+      expect(parsed.app).toBeTruthy();
+      expect(parsed.app.appId).toBeTruthy();
+      expect(parsed.app.adminToken).toBeTruthy();
+      expect(parsed.error).toBeNull();
+    });
+
+    it('fails without --title', async () => {
+      const result = await runCli(['init-without-files', '--temp']);
+      expect(result.exitCode).not.toBe(0);
+    });
+
+    it('fails when title value looks like a flag', async () => {
+      const result = await runCli([
+        'init-without-files',
+        '--title',
+        '--bad-title',
+      ]);
+
+      expect(result.exitCode).not.toBe(0);
+    });
+
+    it('outputs JSON error format on failure', async () => {
+      const result = await runCli(['init-without-files', '--title', 'test']);
+
+      const jsonMatch = result.stdout.match(/\{[\s\S]*\}/);
+      expect(jsonMatch).toBeTruthy();
+
+      const parsed = JSON.parse(jsonMatch![0]);
+      expect(parsed.app).toBeNull();
+      expect(parsed.error).toHaveProperty('message');
+    });
+
+    it('rejects --temp with --org-id', async () => {
+      const result = await runCli([
+        'init-without-files',
+        '--title',
+        'test',
+        '--temp',
+        '--org-id',
+        'org-1',
+      ]);
+
+      expect(result.exitCode).not.toBe(0);
+      const output = result.stdout + result.stderr;
+      expect(output).toMatch(/cannot.*--temp.*--org-id|cannot.*together/i);
+    });
+  });
+
+  describe('push schema', () => {
+    it('pushes schema to a real app', async () => {
+      const { appId, adminToken } = await createTempApp();
+      const project = await createTestProject({
+        appId,
+        schemaFile: SCHEMA_FILE,
+      });
+
+      try {
+        const result = await runCli(['push', 'schema', '--yes'], {
+          cwd: project.dir,
+          env: {
+            INSTANT_CLI_AUTH_TOKEN: adminToken,
+            INSTANT_APP_ID: appId,
+          },
+        });
+
+        expect(result.exitCode).toBe(0);
+        const output = result.stdout + result.stderr;
+        expect(output).toContain('posts');
+      } finally {
+        await project.cleanup();
+      }
+    });
+
+    it('reports no changes on second push', async () => {
+      const { appId, adminToken } = await createTempApp();
+      const project = await createTestProject({
+        appId,
+        schemaFile: SCHEMA_FILE,
+      });
+
+      try {
+        await runCli(['push', 'schema', '--yes'], {
+          cwd: project.dir,
+          env: {
+            INSTANT_CLI_AUTH_TOKEN: adminToken,
+            INSTANT_APP_ID: appId,
+          },
+        });
+
+        const result = await runCli(['push', 'schema', '--yes'], {
+          cwd: project.dir,
+          env: {
+            INSTANT_CLI_AUTH_TOKEN: adminToken,
+            INSTANT_APP_ID: appId,
+          },
+        });
+
+        expect(result.exitCode).toBe(0);
+        const output = result.stdout + result.stderr;
+        expect(output.toLowerCase()).toMatch(/no.*change/);
+      } finally {
+        await project.cleanup();
+      }
+    });
+
+    it('works with --app flag instead of env var', async () => {
+      const { appId, adminToken } = await createTempApp();
+      const project = await createTestProject({
+        schemaFile: SCHEMA_FILE,
+      });
+
+      try {
+        const result = await runCli(
+          ['push', 'schema', '--app', appId, '--yes'],
+          {
+            cwd: project.dir,
+            env: { INSTANT_CLI_AUTH_TOKEN: adminToken },
+          },
+        );
+
+        expect(result.exitCode).toBe(0);
+      } finally {
+        await project.cleanup();
+      }
+    });
+  });
+
+  describe('push schema with --rename', () => {
+    it('renames an attribute', async () => {
+      const { appId, adminToken } = await createTempApp();
+
+      const initialSchema = `
+import { i } from "@instantdb/core";
+const _schema = i.schema({
+  entities: {
+    posts: i.entity({
+      title: i.string(),
+      body: i.string(),
+    }),
+  },
+});
+export default _schema;
+`;
+
+      const renamedSchema = `
+import { i } from "@instantdb/core";
+const _schema = i.schema({
+  entities: {
+    posts: i.entity({
+      name: i.string(),
+      body: i.string(),
+    }),
+  },
+});
+export default _schema;
+`;
+
+      const project1 = await createTestProject({
+        appId,
+        schemaFile: initialSchema,
+      });
+      const seedResult = await runCli(['push', 'schema', '--yes'], {
+        cwd: project1.dir,
+        env: {
+          INSTANT_CLI_AUTH_TOKEN: adminToken,
+          INSTANT_APP_ID: appId,
+        },
+      });
+      expect(seedResult.exitCode).toBe(0);
+      await project1.cleanup();
+
+      const project2 = await createTestProject({
+        appId,
+        schemaFile: renamedSchema,
+      });
+
+      try {
+        const result = await runCli(
+          ['push', 'schema', '--yes', '--rename', 'posts.title:posts.name'],
+          {
+            cwd: project2.dir,
+            env: {
+              INSTANT_CLI_AUTH_TOKEN: adminToken,
+              INSTANT_APP_ID: appId,
+            },
+          },
+        );
+
+        expect(result.exitCode).toBe(0);
+
+        // Pull and verify the rename took effect
+        const pullProject = await createTestProject({ appId });
+        await runCli(['pull', 'schema', '--yes'], {
+          cwd: pullProject.dir,
+          env: {
+            INSTANT_CLI_AUTH_TOKEN: adminToken,
+            INSTANT_APP_ID: appId,
+          },
+        });
+
+        const pulled = await readFile(
+          join(pullProject.dir, 'instant.schema.ts'),
+          'utf-8',
+        );
+        expect(pulled).toContain('name: i.string()');
+        expect(pulled).toContain('body: i.string()');
+        expect(pulled).not.toContain('title: i.string()');
+        await pullProject.cleanup();
+      } finally {
+        await project2.cleanup();
+      }
+    });
+  });
+
+  describe('push perms', () => {
+    it('succeeds gracefully when no perms file exists', async () => {
+      const { appId, adminToken } = await createTempApp();
+      const project = await createTestProject({ appId });
+
+      try {
+        const result = await runCli(['push', 'perms', '--yes'], {
+          cwd: project.dir,
+          env: {
+            INSTANT_CLI_AUTH_TOKEN: adminToken,
+            INSTANT_APP_ID: appId,
+          },
+        });
+
+        expect(result.exitCode).toBe(0);
+      } finally {
+        await project.cleanup();
+      }
+    });
+
+    it('pushes perms to a real app', async () => {
+      const { appId, adminToken } = await createTempApp();
+      const project = await createTestProject({
+        appId,
+        permsFile: PERMS_FILE,
+      });
+
+      try {
+        const result = await runCli(['push', 'perms', '--yes'], {
+          cwd: project.dir,
+          env: {
+            INSTANT_CLI_AUTH_TOKEN: adminToken,
+            INSTANT_APP_ID: appId,
+          },
+        });
+
+        expect(result.exitCode).toBe(0);
+      } finally {
+        await project.cleanup();
+      }
+    });
+  });
+
+  describe('push all', () => {
+    it('pushes both schema and perms', async () => {
+      const { appId, adminToken } = await createTempApp();
+      const project = await createTestProject({
+        appId,
+        schemaFile: SCHEMA_FILE,
+        permsFile: PERMS_FILE,
+      });
+
+      try {
+        const result = await runCli(['push', '--yes'], {
+          cwd: project.dir,
+          env: {
+            INSTANT_CLI_AUTH_TOKEN: adminToken,
+            INSTANT_APP_ID: appId,
+          },
+        });
+
+        expect(result.exitCode).toBe(0);
+      } finally {
+        await project.cleanup();
+      }
+    });
+  });
+
+  describe('pull', () => {
+    it('pulls schema from app with no user-defined entities', async () => {
+      const { appId, adminToken } = await createTempApp();
+      const project = await createTestProject({ appId });
+
+      try {
+        const result = await runCli(['pull', 'schema', '--yes'], {
+          cwd: project.dir,
+          env: {
+            INSTANT_CLI_AUTH_TOKEN: adminToken,
+            INSTANT_APP_ID: appId,
+          },
+        });
+
+        expect(result.exitCode).toBe(0);
+
+        const schemaContent = await readFile(
+          join(project.dir, 'instant.schema.ts'),
+          'utf-8',
+        );
+        expect(schemaContent).toContain('i.schema');
+        expect(schemaContent).not.toContain('posts');
+      } finally {
+        await project.cleanup();
+      }
+    });
+  });
+
+  describe('schema roundtrip', () => {
+    it('push then pull produces matching schema', async () => {
+      const { appId, adminToken } = await createTempApp();
+      const pushProject = await createTestProject({
+        appId,
+        schemaFile: SCHEMA_FILE,
+      });
+      const pushResult = await runCli(['push', 'schema', '--yes'], {
+        cwd: pushProject.dir,
+        env: {
+          INSTANT_CLI_AUTH_TOKEN: adminToken,
+          INSTANT_APP_ID: appId,
+        },
+      });
+      expect(pushResult.exitCode).toBe(0);
+      await pushProject.cleanup();
+
+      const project = await createTestProject({ appId });
+
+      try {
+        const pullResult = await runCli(['pull', 'schema', '--yes'], {
+          cwd: project.dir,
+          env: {
+            INSTANT_CLI_AUTH_TOKEN: adminToken,
+            INSTANT_APP_ID: appId,
+          },
+        });
+        expect(pullResult.exitCode).toBe(0);
+
+        const pulled = await readFile(
+          join(project.dir, 'instant.schema.ts'),
+          'utf-8',
+        );
+
+        expect(pulled).toContain('posts');
+        expect(pulled).toContain('comments');
+        expect(pulled).toContain('title: i.string()');
+        expect(pulled).toContain('body: i.string()');
+        expect(pulled).toContain('text: i.string()');
+        expect(pulled).toContain('postsComments');
+      } finally {
+        await project.cleanup();
+      }
+    });
+  });
+
+  describe('perms roundtrip', () => {
+    it('push then pull produces matching perms', async () => {
+      const { appId, adminToken } = await createTempApp();
+      const pushProject = await createTestProject({
+        appId,
+        permsFile: PERMS_FILE,
+      });
+      const pushResult = await runCli(['push', 'perms', '--yes'], {
+        cwd: pushProject.dir,
+        env: {
+          INSTANT_CLI_AUTH_TOKEN: adminToken,
+          INSTANT_APP_ID: appId,
+        },
+      });
+      expect(pushResult.exitCode).toBe(0);
+      await pushProject.cleanup();
+
+      const project = await createTestProject({ appId });
+
+      try {
+        await runCli(['pull', 'perms', '--yes'], {
+          cwd: project.dir,
+          env: {
+            INSTANT_CLI_AUTH_TOKEN: adminToken,
+            INSTANT_APP_ID: appId,
+          },
+        });
+
+        const pulled = await readFile(
+          join(project.dir, 'instant.perms.ts'),
+          'utf-8',
+        );
+        expect(pulled).toContain('posts');
+        expect(pulled).toContain('view');
+        expect(pulled).toContain('"true"');
+        expect(pulled).toContain('create');
+      } finally {
+        await project.cleanup();
+      }
+    });
+  });
+
+  describe('pull all', () => {
+    it('pulls both schema and perms', async () => {
+      const { appId, adminToken } = await createTempApp();
+      const pushProject = await createTestProject({
+        appId,
+        schemaFile: SCHEMA_FILE,
+        permsFile: PERMS_FILE,
+      });
+      const pushResult = await runCli(['push', '--yes'], {
+        cwd: pushProject.dir,
+        env: {
+          INSTANT_CLI_AUTH_TOKEN: adminToken,
+          INSTANT_APP_ID: appId,
+        },
+      });
+      expect(pushResult.exitCode).toBe(0);
+      await pushProject.cleanup();
+
+      const project = await createTestProject({ appId });
+
+      try {
+        const result = await runCli(['pull', '--yes'], {
+          cwd: project.dir,
+          env: {
+            INSTANT_CLI_AUTH_TOKEN: adminToken,
+            INSTANT_APP_ID: appId,
+          },
+        });
+
+        expect(result.exitCode).toBe(0);
+
+        const schemaContent = await readFile(
+          join(project.dir, 'instant.schema.ts'),
+          'utf-8',
+        );
+        expect(schemaContent).toContain('posts');
+
+        const permsContent = await readFile(
+          join(project.dir, 'instant.perms.ts'),
+          'utf-8',
+        );
+        expect(permsContent).toContain('posts');
+      } finally {
+        await project.cleanup();
+      }
+    });
+  });
+
+  describe('info', () => {
+    it('shows version', async () => {
+      const result = await runCli(['info']);
+
+      expect(result.exitCode).toBe(0);
+      const output = result.stdout + result.stderr;
+      expect(output.toLowerCase()).toMatch(/version/i);
+    });
+
+    it('shows not logged in without token', async () => {
+      const result = await runCli(['info'], {
+        env: { INSTANT_CLI_AUTH_TOKEN: '' },
+      });
+
+      const output = result.stdout + result.stderr;
+      expect(output.toLowerCase()).toMatch(/not logged in/);
+    });
+  });
+
+  describe('logout', () => {
+    it('prints logged out message', async () => {
+      const result = await runCli(['logout']);
+
+      expect(result.exitCode).toBe(0);
+      const output = result.stdout + result.stderr;
+      expect(output.toLowerCase()).toMatch(/logged out/);
+    });
+  });
+
+  describe('claim', () => {
+    it('fails when not logged in', async () => {
+      const result = await runCli(['claim'], {
+        env: {
+          INSTANT_CLI_AUTH_TOKEN: '',
+          INSTANT_APP_ID: 'fake-app-id',
+          INSTANT_APP_ADMIN_TOKEN: 'fake-token',
+        },
+      });
+
+      expect(result.exitCode).not.toBe(0);
+    });
+
+    it('fails when no app ID in env', async () => {
+      const result = await runCli(['claim'], {
+        env: {
+          INSTANT_CLI_AUTH_TOKEN: 'some-token',
+          INSTANT_APP_ID: '',
+          INSTANT_APP_ADMIN_TOKEN: '',
+        },
+      });
+
+      expect(result.exitCode).not.toBe(0);
+    });
+  });
+});

package/__tests__/e2e/helpers.ts

@@ -0,0 +1,133 @@
+import { execFile } from 'child_process';
+import { mkdtemp, writeFile, mkdir, rm } from 'fs/promises';
+import { join, dirname } from 'path';
+import { tmpdir } from 'os';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const CLI_BIN = join(__dirname, '../../bin/index.js');
+
+const apiUrl = process.env.INSTANT_CLI_API_URI || 'https://api.instantdb.com';
+
+// Temp directory used to sandbox CLI config (auth tokens, etc.)
+// so tests never read or mutate the real user config on disk.
+const sandboxHome = join(tmpdir(), 'instant-cli-e2e-home');
+
+export type CliResult = {
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+};
+
+export function runCli(
+  args: string[],
+  opts: {
+    env?: Record<string, string>;
+    cwd?: string;
+  } = {},
+): Promise<CliResult> {
+  return new Promise((resolve) => {
+    execFile(
+      process.execPath,
+      [CLI_BIN, ...args],
+      {
+        env: {
+          ...process.env,
+          INSTANT_CLI_API_URI: apiUrl,
+          DOTENV_CONFIG_PATH: '/dev/null',
+          INSTANT_CLI_AUTH_TOKEN: '',
+          HOME: sandboxHome,
+          XDG_CONFIG_HOME: join(sandboxHome, '.config'),
+          XDG_DATA_HOME: join(sandboxHome, '.local', 'share'),
+          ...opts.env,
+        },
+        cwd: opts.cwd,
+        timeout: 30_000,
+      },
+      (error, stdout, stderr) => {
+        resolve({
+          stdout: stdout?.toString() ?? '',
+          stderr: stderr?.toString() ?? '',
+          exitCode: error
+            ? typeof error.code === 'number'
+              ? error.code
+              : 1
+            : 0,
+        });
+      },
+    );
+  });
+}
+
+export type TestProject = {
+  dir: string;
+  cleanup: () => Promise<void>;
+};
+
+export async function createTestProject(
+  opts: {
+    appId?: string;
+    schemaFile?: string;
+    permsFile?: string;
+  } = {},
+): Promise<TestProject> {
+  const dir = await mkdtemp(join(tmpdir(), 'instant-cli-e2e-'));
+
+  await writeFile(
+    join(dir, 'package.json'),
+    JSON.stringify(
+      {
+        name: 'e2e-test-project',
+        version: '1.0.0',
+        dependencies: { '@instantdb/react': '^0.0.1' },
+      },
+      null,
+      2,
+    ),
+  );
+
+  await mkdir(join(dir, 'node_modules', '@instantdb', 'react'), {
+    recursive: true,
+  });
+  await writeFile(
+    join(dir, 'node_modules', '@instantdb', 'react', 'package.json'),
+    JSON.stringify({ name: '@instantdb/react', version: '0.0.1' }),
+  );
+
+  if (opts.appId) {
+    await writeFile(join(dir, '.env'), `INSTANT_APP_ID=${opts.appId}\n`);
+  }
+
+  if (opts.schemaFile) {
+    await writeFile(join(dir, 'instant.schema.ts'), opts.schemaFile);
+  }
+
+  if (opts.permsFile) {
+    await writeFile(join(dir, 'instant.perms.ts'), opts.permsFile);
+  }
+
+  return {
+    dir,
+    async cleanup() {
+      await rm(dir, { recursive: true, force: true });
+    },
+  };
+}
+
+export async function createTempApp(title = 'cli-e2e-test'): Promise<{
+  appId: string;
+  adminToken: string;
+}> {
+  const response = await fetch(`${apiUrl}/dash/apps/ephemeral`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ title }),
+  });
+  if (!response.ok) {
+    throw new Error(
+      `Failed to create ephemeral app: ${response.status} ${await response.text()}`,
+    );
+  }
+  const { app } = await response.json();
+  return { appId: app.id, adminToken: app['admin-token'] };
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "instant-cli",
   "type": "module",
-  "version": "0.22.155",
+  "version": "0.22.156",
   "description": "Instant's CLI",
   "homepage": "https://github.com/instantdb/instant/tree/main/client/packages/cli",
   "repository": {
@@ -41,9 +41,9 @@
     "strip-ansi": "^7.1.2",
     "terminal-link": "^3.0.0",
     "unconfig": "^0.5.5",
-    "@instantdb/core": "0.22.155",
-    "@instantdb/platform": "0.22.155",
-    "@instantdb/version": "0.22.155"
+    "@instantdb/core": "0.22.156",
+    "@instantdb/platform": "0.22.156",
+    "@instantdb/version": "0.22.156"
   },
   "devDependencies": {
     "@babel/core": "^7.17.9",
@@ -58,7 +58,7 @@
   "scripts": {
     "build": "rm -rf dist; tsc -p tsconfig.json",
     "dev": "tsc -p tsconfig.json --watch --skipLibCheck --preserveWatchOutput | grep -v '^$'",
-    "test": "vitest",
+    "test": "vitest --project unit",
     "test:ci": "vitest run",
     "publish-package": "pnpm pack && npm publish *.tgz --access public",
     "clean": "rm -rf dist"

package/vitest.config.ts

@@ -0,0 +1,21 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    projects: [
+      {
+        test: {
+          name: 'unit',
+          include: ['**/*.test.ts'],
+          exclude: ['**/*.e2e.test.ts'],
+        },
+      },
+      {
+        test: {
+          name: 'e2e',
+          include: ['**/*.e2e.test.ts'],
+        },
+      },
+    ],
+  },
+});