@mx-space/cli 0.15.0 → 0.15.1

package/dist/test/cli/snippet-crud.test.js

@@ -0,0 +1,293 @@
+import { Effect, Exit, Layer, Option } from 'effect';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { create as putSnippet } from '../../src/cli/snippet/create';
+import { del as deleteSnippet } from '../../src/cli/snippet/delete';
+import { edit as editSnippet } from '../../src/cli/snippet/edit';
+import { get as getSnippet } from '../../src/cli/snippet/get';
+import { list as listSnippet } from '../../src/cli/snippet/list';
+import { update as moveSnippet } from '../../src/cli/snippet/update';
+import { Api } from '../../src/services/Api';
+import { Editor } from '../../src/services/Editor';
+import { Renderer } from '../../src/services/Renderer';
+import { makeMemFs, TestFsLive, TestPathLive } from '../helper/test-fs';
+const rendererJson = {
+    json: true,
+    output: 'json',
+    quiet: false,
+    verbose: false,
+};
+const captureStdout = () => {
+    const orig = process.stdout.write.bind(process.stdout);
+    process.stdout.write = () => true;
+    return {
+        restore: () => {
+            ;
+            process.stdout.write = orig;
+        },
+    };
+};
+const SNIPPET_ID = '900000000000000001';
+const fullSnippet = {
+    id: SNIPPET_ID,
+    path: 'root/config.json',
+    type: 'json',
+    raw: '{"a":1}',
+    private: true,
+    comment: 'old comment',
+    metatype: null,
+    schema: null,
+    method: null,
+    secret: null,
+    enable: true,
+};
+const makeApi = (calls, responses = {}) => ({
+    request: (path, options) => Effect.sync(() => {
+        calls.push({ path, options });
+        return (responses[path] ?? { id: SNIPPET_ID });
+    }),
+    raw: (path, options) => Effect.sync(() => {
+        calls.push({ path, options });
+        return responses[path] ?? { ok: true };
+    }),
+});
+const makeEditor = (overrides = {}) => ({
+    openEditor: (opts) => Effect.succeed(opts.initialContent),
+    prompt: () => Effect.succeed(''),
+    confirm: () => Effect.succeed(true),
+    readFileOrStdin: () => Effect.succeed(''),
+    ...overrides,
+});
+const buildLayer = (calls, responses = {}, editor) => Layer.mergeAll(TestFsLive(makeMemFs()), TestPathLive, Layer.succeed(Api, makeApi(calls, responses)), Renderer.Default, Layer.succeed(Editor, editor ?? makeEditor()));
+const withStdinTty = (value) => {
+    const descriptor = Object.getOwnPropertyDescriptor(process.stdin, 'isTTY');
+    Object.defineProperty(process.stdin, 'isTTY', {
+        configurable: true,
+        value,
+    });
+    return () => {
+        if (descriptor)
+            Object.defineProperty(process.stdin, 'isTTY', descriptor);
+    };
+};
+afterEach(() => {
+    vi.restoreAllMocks();
+});
+const none = () => Option.none();
+const writeFlags = {
+    type: Option.none(),
+    file: none(),
+    raw: none(),
+    comment: none(),
+    method: Option.none(),
+    metatype: none(),
+    schema: none(),
+    secret: none(),
+    private: false,
+    noPrivate: false,
+    enable: false,
+    noEnable: false,
+};
+describe('snippet VFS command handlers', () => {
+    it('lists snippet paths by prefix', async () => {
+        const calls = [];
+        const stdout = captureStdout();
+        try {
+            const exit = await Effect.runPromiseExit(listSnippet
+                .handler({
+                prefix: Option.some('sk/'),
+                limit: Option.some(20),
+                recursive: true,
+            })
+                .pipe(Effect.provide(buildLayer(calls)), Renderer.withOptions(rendererJson)));
+            expect(Exit.isSuccess(exit)).toBe(true);
+            expect(calls[0]).toMatchObject({
+                path: '/snippets',
+                options: { query: { prefix: 'sk/', limit: 20, recursive: true } },
+            });
+        }
+        finally {
+            stdout.restore();
+        }
+    });
+    it('gets a snippet by path', async () => {
+        const calls = [];
+        const stdout = captureStdout();
+        try {
+            const exit = await Effect.runPromiseExit(getSnippet.handler({ target: 'root/config.json' }).pipe(Effect.provide(buildLayer(calls)), Renderer.withOptions(rendererJson)));
+            expect(Exit.isSuccess(exit)).toBe(true);
+            expect(calls[0]).toMatchObject({
+                path: '/snippets/by-path',
+                options: { query: { path: 'root/config.json' } },
+            });
+        }
+        finally {
+            stdout.restore();
+        }
+    });
+    it('gets a snippet by snowflake id directly', async () => {
+        const calls = [];
+        const stdout = captureStdout();
+        try {
+            const exit = await Effect.runPromiseExit(getSnippet.handler({ target: SNIPPET_ID }).pipe(Effect.provide(buildLayer(calls)), Renderer.withOptions(rendererJson)));
+            expect(Exit.isSuccess(exit)).toBe(true);
+            expect(calls[0].path).toBe(`/snippets/${SNIPPET_ID}`);
+        }
+        finally {
+            stdout.restore();
+        }
+    });
+    it('puts a snippet from --raw', async () => {
+        const calls = [];
+        const stdout = captureStdout();
+        try {
+            const exit = await Effect.runPromiseExit(putSnippet
+                .handler({
+                path: 'root/config.json',
+                ...writeFlags,
+                type: Option.some('json'),
+                raw: Option.some('{"b":2}'),
+                private: true,
+            })
+                .pipe(Effect.provide(buildLayer(calls)), Renderer.withOptions(rendererJson)));
+            expect(Exit.isSuccess(exit)).toBe(true);
+            expect(calls[0]).toMatchObject({
+                path: '/snippets/by-path',
+                options: { method: 'PUT' },
+            });
+            const body = calls[0].options
+                .body;
+            expect(body).toEqual({
+                path: 'root/config.json',
+                type: 'json',
+                raw: '{"b":2}',
+                private: true,
+            });
+        }
+        finally {
+            stdout.restore();
+        }
+    });
+    it('put falls back to piped stdin when no source flag is given', async () => {
+        const calls = [];
+        const editor = makeEditor({
+            readFileOrStdin: () => Effect.succeed('from stdin'),
+        });
+        const restoreTty = withStdinTty(false);
+        const stdout = captureStdout();
+        try {
+            const exit = await Effect.runPromiseExit(putSnippet.handler({ path: 'root/config.txt', ...writeFlags }).pipe(Effect.provide(buildLayer(calls, {}, editor)), Renderer.withOptions(rendererJson)));
+            expect(Exit.isSuccess(exit)).toBe(true);
+            const body = calls[0].options
+                .body;
+            expect(body.raw).toBe('from stdin');
+        }
+        finally {
+            stdout.restore();
+            restoreTty();
+        }
+    });
+    it('moves a snippet path', async () => {
+        const calls = [];
+        const stdout = captureStdout();
+        try {
+            const exit = await Effect.runPromiseExit(moveSnippet
+                .handler({
+                from: 'sk/foo/',
+                to: 'sk/bar/',
+                recursive: true,
+            })
+                .pipe(Effect.provide(buildLayer(calls)), Renderer.withOptions(rendererJson)));
+            expect(Exit.isSuccess(exit)).toBe(true);
+            expect(calls[0]).toMatchObject({
+                path: '/snippets/move',
+                options: {
+                    method: 'POST',
+                    body: { from: 'sk/foo/', to: 'sk/bar/', recursive: true },
+                },
+            });
+        }
+        finally {
+            stdout.restore();
+        }
+    });
+    it('edit: unchanged buffer exits without a PUT', async () => {
+        const calls = [];
+        const responses = {
+            [`/snippets/${SNIPPET_ID}`]: fullSnippet,
+        };
+        const filenames = [];
+        const editor = makeEditor({
+            openEditor: (opts) => Effect.sync(() => {
+                filenames.push(opts.filename);
+                return opts.initialContent;
+            }),
+        });
+        const stdout = captureStdout();
+        try {
+            const exit = await Effect.runPromiseExit(editSnippet.handler({ target: SNIPPET_ID }).pipe(Effect.provide(buildLayer(calls, responses, editor)), Renderer.withOptions(rendererJson)));
+            expect(Exit.isSuccess(exit)).toBe(true);
+            expect(calls).toHaveLength(1);
+            expect(filenames).toEqual(['snippet.json']);
+        }
+        finally {
+            stdout.restore();
+        }
+    });
+    it('edit: changed path buffer PUTs by path', async () => {
+        const calls = [];
+        const responses = {
+            '/snippets/by-path': fullSnippet,
+        };
+        const editor = makeEditor({
+            openEditor: () => Effect.succeed('{"a":3}'),
+        });
+        const stdout = captureStdout();
+        try {
+            const exit = await Effect.runPromiseExit(editSnippet.handler({ target: 'root/config.json' }).pipe(Effect.provide(buildLayer(calls, responses, editor)), Renderer.withOptions(rendererJson)));
+            expect(Exit.isSuccess(exit)).toBe(true);
+            expect(calls[1]).toMatchObject({
+                path: '/snippets/by-path',
+                options: { method: 'PUT' },
+            });
+            const body = calls[1].options
+                .body;
+            expect(body.raw).toBe('{"a":3}');
+            expect(body.path).toBe('root/config.json');
+        }
+        finally {
+            stdout.restore();
+        }
+    });
+    it('deletes a snippet path when --force is supplied', async () => {
+        const calls = [];
+        const stdout = captureStdout();
+        try {
+            const exit = await Effect.runPromiseExit(deleteSnippet
+                .handler({ target: 'sk/foo/', force: true, recursive: true })
+                .pipe(Effect.provide(buildLayer(calls)), Renderer.withOptions(rendererJson)));
+            expect(Exit.isSuccess(exit)).toBe(true);
+            expect(calls[0]).toMatchObject({
+                path: '/snippets/by-path',
+                options: {
+                    method: 'DELETE',
+                    query: { path: 'sk/foo/', recursive: true },
+                },
+            });
+        }
+        finally {
+            stdout.restore();
+        }
+    });
+    it('refuses snippet delete without --force in non-TTY', async () => {
+        const restoreTty = withStdinTty(false);
+        try {
+            const exit = await Effect.runPromiseExit(deleteSnippet
+                .handler({ target: SNIPPET_ID, force: false, recursive: false })
+                .pipe(Effect.provide(buildLayer([]))));
+            expect(Exit.isFailure(exit)).toBe(true);
+        }
+        finally {
+            restoreTty();
+        }
+    });
+});

package/dist/test/cli/topic/topic.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/cli/topic/topic.test.js

@@ -0,0 +1,181 @@
+import { Effect, Exit, Layer, Option } from 'effect';
+import { describe, expect, it } from 'vitest';
+import { create } from '../../../src/cli/topic/create';
+import { del } from '../../../src/cli/topic/delete';
+import { get } from '../../../src/cli/topic/get';
+import { list } from '../../../src/cli/topic/list';
+import { update } from '../../../src/cli/topic/update';
+import { Api } from '../../../src/services/Api';
+import { Auth } from '../../../src/services/Auth';
+import { Config, } from '../../../src/services/Config';
+import { Renderer } from '../../../src/services/Renderer';
+import { testHttpLayer } from '../../helper/test-http';
+const baseResolved = {
+    apiUrl: 'https://blog.example.com',
+    apiBase: 'https://blog.example.com/api/v2',
+    authBase: 'https://blog.example.com/api/v2/auth',
+    apiVersion: 2,
+    clientId: 'mxs-cli',
+    configPath: '/tmp/config.json',
+    credentialsPath: '/tmp/credentials.json',
+    profileName: 'dev',
+    isProduction: false,
+    profileExplicit: false,
+    urlOverridden: false,
+};
+const mockConfigLayer = (resolved) => {
+    const service = {
+        getConfigDir: Effect.succeed('/tmp'),
+        getProfilesDir: Effect.succeed('/tmp/profiles'),
+        getProfileDir: (name) => Effect.succeed(`/tmp/profiles/${name}`),
+        getProfileConfigPath: (name) => Effect.succeed(`/tmp/profiles/${name}/config.json`),
+        getProfileCredentialsPath: (name) => Effect.succeed(`/tmp/profiles/${name}/credentials.json`),
+        getCurrentPath: Effect.succeed('/tmp/current'),
+        getLegacyConfigPath: Effect.succeed('/tmp/config.json'),
+        getLegacyCredentialsPath: Effect.succeed('/tmp/credentials.json'),
+        readProfileConfig: () => Effect.succeed({}),
+        writeProfileConfig: () => Effect.void,
+        updateProfileConfig: () => Effect.succeed({}),
+        readProfileCredentials: () => Effect.succeed(null),
+        writeProfileCredentials: () => Effect.void,
+        deleteProfileCredentials: () => Effect.void,
+        readLegacyConfig: Effect.succeed({}),
+        readLegacyConfigRaw: Effect.succeed(null),
+        readLegacyCredentialsRaw: Effect.succeed(null),
+        deleteLegacyConfig: Effect.void,
+        deleteLegacyCredentials: Effect.void,
+        readCurrent: Effect.succeed(resolved.profileName),
+        writeCurrent: () => Effect.void,
+        listProfileDirs: Effect.succeed([]),
+        profileExists: () => Effect.succeed(true),
+        removeProfileDir: () => Effect.void,
+        resolve: () => Effect.succeed(resolved),
+    };
+    return Layer.succeed(Config, service);
+};
+const mockAuthLayer = Layer.succeed(Auth, {
+    probe: () => Effect.die('probe not used'),
+    requestDeviceCode: () => Effect.die('requestDeviceCode not used'),
+    pollDeviceToken: () => Effect.die('pollDeviceToken not used'),
+    refresh: () => Effect.succeed(null),
+    login: () => Effect.die('login not used'),
+    logout: () => Effect.void,
+    whoami: Effect.die('whoami not used'),
+    status: Effect.die('status not used'),
+    ensureFresh: () => Effect.die('ensureFresh not used'),
+    enrichUser: (_profile, _authBase, cred) => Effect.succeed(cred),
+});
+const buildLayer = (http, resolved = baseResolved) => Layer.mergeAll(Api.layer({ quiet: true }).pipe(Layer.provide(mockConfigLayer(resolved)), Layer.provide(mockAuthLayer), Layer.provide(http.layer)), Renderer.Default);
+describe('topic list command', () => {
+    it('GETs /topics/all', async () => {
+        const http = testHttpLayer({
+            'GET https://blog.example.com/api/v2/topics/all': {
+                status: 200,
+                body: [{ id: 't1', slug: 'random' }],
+            },
+        });
+        const exit = await Effect.runPromiseExit(list.handler({}).pipe(Effect.provide(buildLayer(http))));
+        expect(Exit.isSuccess(exit)).toBe(true);
+        expect(http.recorder.calls.length).toBe(1);
+    });
+});
+describe('topic get command', () => {
+    it('uses /topics/slug/:slug for non-snowflake refs', async () => {
+        const http = testHttpLayer({
+            'GET https://blog.example.com/api/v2/topics/slug/random': {
+                status: 200,
+                body: { id: 't1', slug: 'random' },
+            },
+        });
+        const exit = await Effect.runPromiseExit(get
+            .handler({ slugOrId: 'random' })
+            .pipe(Effect.provide(buildLayer(http))));
+        expect(Exit.isSuccess(exit)).toBe(true);
+    });
+    it('uses /topics/:id for snowflake ids', async () => {
+        const http = testHttpLayer({
+            'GET https://blog.example.com/api/v2/topics/123456789012345': {
+                status: 200,
+                body: { id: '123456789012345' },
+            },
+        });
+        const exit = await Effect.runPromiseExit(get
+            .handler({ slugOrId: '123456789012345' })
+            .pipe(Effect.provide(buildLayer(http))));
+        expect(Exit.isSuccess(exit)).toBe(true);
+    });
+});
+describe('topic create command', () => {
+    it('POSTs /topics with name+slug (+ optional description/icon)', async () => {
+        const http = testHttpLayer({
+            'POST https://blog.example.com/api/v2/topics': {
+                status: 200,
+                body: { ok: true },
+            },
+        });
+        const exit = await Effect.runPromiseExit(create
+            .handler({
+            name: 'Random',
+            slug: 'random',
+            description: Option.some('Random thoughts'),
+            icon: Option.none(),
+        })
+            .pipe(Effect.provide(buildLayer(http, { ...baseResolved, profileExplicit: true }))));
+        expect(Exit.isSuccess(exit)).toBe(true);
+        expect(http.recorder.calls[0]?.body).toEqual({
+            name: 'Random',
+            slug: 'random',
+            description: 'Random thoughts',
+        });
+    });
+});
+describe('topic update command', () => {
+    it('resolves slug → id then PATCH /topics/:id', async () => {
+        const http = testHttpLayer({
+            'GET https://blog.example.com/api/v2/topics/slug/random': {
+                status: 200,
+                body: { id: 't1', slug: 'random' },
+            },
+            'PATCH https://blog.example.com/api/v2/topics/t1': {
+                status: 200,
+                body: { ok: true },
+            },
+        });
+        const exit = await Effect.runPromiseExit(update
+            .handler({
+            slugOrId: 'random',
+            name: Option.some('Renamed'),
+            slug: Option.none(),
+            description: Option.none(),
+            icon: Option.none(),
+        })
+            .pipe(Effect.provide(buildLayer(http, { ...baseResolved, profileExplicit: true }))));
+        expect(Exit.isSuccess(exit)).toBe(true);
+        expect(http.recorder.calls.length).toBe(2);
+        expect(http.recorder.calls[1]?.body).toEqual({ name: 'Renamed' });
+    });
+});
+describe('topic delete command', () => {
+    it('refuses without --force in non-TTY context', async () => {
+        const http = testHttpLayer({});
+        const exit = await Effect.runPromiseExit(del
+            .handler({ slugOrId: '123456789012345', force: false })
+            .pipe(Effect.provide(buildLayer(http))));
+        expect(Exit.isFailure(exit)).toBe(true);
+        expect(http.recorder.calls.length).toBe(0);
+    });
+    it('deletes via DELETE /topics/:id with --force on snowflake id', async () => {
+        const http = testHttpLayer({
+            'DELETE https://blog.example.com/api/v2/topics/123456789012345': {
+                status: 200,
+                body: {},
+            },
+        });
+        const exit = await Effect.runPromiseExit(del
+            .handler({ slugOrId: '123456789012345', force: true })
+            .pipe(Effect.provide(buildLayer(http, { ...baseResolved, profileExplicit: true }))));
+        expect(Exit.isSuccess(exit)).toBe(true);
+        expect(http.recorder.calls.length).toBe(1);
+        expect(http.recorder.calls[0]?.method).toBe('DELETE');
+    });
+});

package/dist/test/cli/update.test.d.ts

@@ -0,0 +1 @@
+export {};