SnowLuma v2.4.2 source snapshot

packages/sdk/tests/package.test.ts

@@ -0,0 +1,261 @@
+import { spawnSync } from 'node:child_process';
+import {
+    copyFileSync,
+    cpSync,
+    mkdirSync,
+    mkdtempSync,
+    readFileSync,
+    rmSync,
+    symlinkSync,
+    writeFileSync,
+} from 'node:fs';
+import { createRequire } from 'node:module';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { afterAll, beforeAll, describe, it } from 'vitest';
+
+const sdkRoot = fileURLToPath(new URL('..', import.meta.url));
+const compiler = createRequire(import.meta.url).resolve('typescript/bin/tsc');
+const manifest = JSON.parse(readFileSync(path.join(sdkRoot, 'package.json'), 'utf8')) as {
+    name: string;
+    exports: Record<string, string | { import: string; types: string }>;
+};
+const entrypoints = Object.entries(manifest.exports)
+    .filter(([, target]) => typeof target !== 'string')
+    .map(([entry]) => `${manifest.name}${entry === '.' ? '' : entry.slice(1)}`);
+let consumerRoot: string;
+
+function node(args: string[]): void {
+    const result = spawnSync(process.execPath, args, {
+        cwd: consumerRoot,
+        encoding: 'utf8',
+        stdio: 'pipe',
+        timeout: 30_000,
+    });
+
+    if (result.error) {
+        throw result.error;
+    }
+
+    if (result.status !== 0) {
+        throw new Error(
+            `Node exited with status ${result.status} (signal ${result.signal}):\n${result.stdout}\n${result.stderr}`,
+        );
+    }
+}
+
+beforeAll(() => {
+    consumerRoot = mkdtempSync(path.join(tmpdir(), 'snowluma-sdk-package-'));
+    const installed = path.join(consumerRoot, 'node_modules', '@snowluma', 'sdk');
+    mkdirSync(installed, { recursive: true });
+    copyFileSync(path.join(sdkRoot, 'package.json'), path.join(installed, 'package.json'));
+    // Install the declared runtime dependency into this isolated consumer. Node
+    // type declarations belong to the consuming Node project's dev environment.
+    const require = createRequire(import.meta.url);
+    cpSync(
+        path.dirname(require.resolve('ws/package.json')),
+        path.join(consumerRoot, 'node_modules', 'ws'),
+        { recursive: true },
+    );
+    mkdirSync(path.join(consumerRoot, 'node_modules', '@types'), { recursive: true });
+    symlinkSync(
+        path.dirname(require.resolve('@types/node/package.json')),
+        path.join(consumerRoot, 'node_modules', '@types', 'node'),
+        'dir',
+    );
+
+    copyFileSync(
+        path.join(sdkRoot, 'tests', 'fixtures', 'action-types.mts'),
+        path.join(consumerRoot, 'action-types.mts'),
+    );
+    copyFileSync(
+        path.join(sdkRoot, 'tests', 'fixtures', 'action-contracts.ts'),
+        path.join(consumerRoot, 'action-contracts.ts'),
+    );
+    copyFileSync(
+        path.join(sdkRoot, 'tests', 'fixtures', 'messaging-types.mts'),
+        path.join(consumerRoot, 'messaging-types.mts'),
+    );
+
+    writeFileSync(
+        path.join(consumerRoot, 'reverse-types.mts'),
+        `import { text } from '@snowluma/sdk';
+import { createReverseWebSocketServer, type SnowLumaReverseWebSocketSession } from '@snowluma/sdk/node';
+const reverse = createReverseWebSocketServer({ port: 0, selfIds: ['10001'] });
+reverse.on('connection', (bot: SnowLumaReverseWebSocketSession) => {
+    const id: string = bot.selfId;
+    const ready: boolean = bot.canCallActions;
+    void bot.getStatus();
+    bot.onMessage(async (_event, context) => { await context.reply(text(id)); });
+    void ready;
+});
+`,
+    );
+
+    writeFileSync(
+        path.join(consumerRoot, 'browser-types.mts'),
+        `
+import { SnowLumaWebSocketClient, text } from '@snowluma/sdk';
+new SnowLumaWebSocketClient().onMessage(async (_event, context) => { await context.reply(text('hello')); });
+// @ts-expect-error Node globals must not leak through the browser entry.
+process.cwd();
+`,
+    );
+    writeFileSync(
+        path.join(consumerRoot, 'tsconfig.browser.json'),
+        JSON.stringify({
+            compilerOptions: {
+                strict: true,
+                noEmit: true,
+                target: 'ES2022',
+                lib: ['ES2022', 'DOM'],
+                module: 'ESNext',
+                moduleResolution: 'Bundler',
+                types: [],
+            },
+            files: ['browser-types.mts'],
+        }),
+    );
+
+    // Compile fresh output outside the workspace so neither stale dist files nor
+    // Vitest's source resolver can hide a broken published entry point.
+    node([
+        compiler,
+        '--project',
+        path.join(sdkRoot, 'tsconfig.json'),
+        '--outDir',
+        path.join(installed, 'dist'),
+    ]);
+    writeFileSync(
+        path.join(consumerRoot, 'consumer.mts'),
+        `import { SnowLumaHttpClient, text, type SnowLumaKnownAction as RootKnownAction } from '@snowluma/sdk';
+import { SnowLumaWebSocketClient, type SnowLumaHttpClientOptions } from '@snowluma/sdk/client';
+import { MessageChain } from '@snowluma/sdk/messages';
+import { isMessageEvent, type EventMiddleware } from '@snowluma/sdk/events';
+import { SnowLumaApiError } from '@snowluma/sdk/errors';
+import { SNOWLUMA_ACTIONS, isSnowLumaAction, type SnowLumaKnownAction } from '@snowluma/sdk/actions';
+import type { ActionParams, StatusInfo } from '@snowluma/sdk/types';
+
+const options: SnowLumaHttpClientOptions = { baseUrl: 'http://127.0.0.1:3000/' };
+const client = new SnowLumaHttpClient(options);
+const status: Promise<StatusInfo> = client.getStatus();
+const message: MessageChain = text('hello').reply(-42);
+const params: ActionParams<'send_group_msg'> = { group_id: 123, message: [] };
+client.raw('send_group_msg', params);
+client.raw('consumer_extension', { custom: true });
+client.sendGroupMessage(123, message);
+const middleware: EventMiddleware = async (event, context, next) => {
+    if (isMessageEvent(event)) await context.reply(text('received'));
+    await next();
+};
+new SnowLumaWebSocketClient().use(middleware);
+const action: RootKnownAction = SNOWLUMA_ACTIONS[0];
+function known(value: string): SnowLumaKnownAction | null {
+    return isSnowLumaAction(value) ? value : null;
+}
+const error = new SnowLumaApiError({ status: 'failed', retcode: 1, data: null });
+export { status, action, known, error };
+`,
+    );
+}, 30_000);
+
+afterAll(() => {
+    if (consumerRoot) {
+        rmSync(consumerRoot, { recursive: true, force: true });
+    }
+});
+
+describe('SDK package entry points', () => {
+    it('keeps browser consumers independent of Node server declarations', () => {
+        node([compiler, '-p', path.join(consumerRoot, 'tsconfig.browser.json')]);
+    }, 30_000);
+
+    it('starts the published Node reverse server without workspace resolution', () => {
+        node([
+            '--input-type=module',
+            '--eval',
+            `
+import assert from 'node:assert/strict';
+import { createReverseWebSocketServer } from '@snowluma/sdk/node';
+const server = createReverseWebSocketServer({ port: 0 });
+await server.listen();
+assert.ok(server.address.port > 0);
+await server.close();
+`,
+        ]);
+    });
+
+    it.each(entrypoints)('loads %s in native Node without a bundler', (entrypoint) => {
+        node(['--input-type=module', '--eval', `await import(${JSON.stringify(entrypoint)});`]);
+    });
+
+    it('preserves runtime identities across the root and subpath exports', () => {
+        node([
+            '--input-type=module',
+            '--eval',
+            `import assert from 'node:assert/strict';
+import * as sdk from '@snowluma/sdk';
+import * as client from '@snowluma/sdk/client';
+import * as messages from '@snowluma/sdk/messages';
+import * as events from '@snowluma/sdk/events';
+import * as errors from '@snowluma/sdk/errors';
+import * as actions from '@snowluma/sdk/actions';
+assert.equal(sdk.SnowLumaHttpClient, client.SnowLumaHttpClient);
+assert.equal(sdk.SnowLumaWebSocketClient, client.SnowLumaWebSocketClient);
+assert.equal(sdk.MessageChain, messages.MessageChain);
+assert.equal(sdk.quoteMessage, messages.quoteMessage);
+assert.equal(sdk.isMessageEvent, events.isMessageEvent);
+assert.equal(sdk.SnowLumaApiError, errors.SnowLumaApiError);
+assert.equal(sdk.SnowLumaMediaSendError, errors.SnowLumaMediaSendError);
+assert.equal(sdk.SNOWLUMA_ACTIONS, actions.SNOWLUMA_ACTIONS);
+assert.equal(sdk.isSnowLumaAction, actions.isSnowLumaAction);
+assert.ok(sdk.text('hello') instanceof messages.MessageChain);
+assert.equal(actions.isSnowLumaAction('send_group_msg'), true);
+assert.equal(actions.isSnowLumaAction('consumer_extension'), false);
+`,
+        ]);
+    });
+
+    it.each([
+        ['NodeNext', 'NodeNext'],
+        ['ESNext', 'Bundler'],
+    ])(
+        'typechecks a consumer using %s / %s',
+        (module, resolution) => {
+            node([
+                compiler,
+                '--noEmit',
+                '--strict',
+                '--target',
+                'ES2022',
+                '--lib',
+                'ES2022,DOM',
+                '--module',
+                module,
+                '--moduleResolution',
+                resolution,
+                path.join(consumerRoot, 'consumer.mts'),
+                path.join(consumerRoot, 'action-types.mts'),
+                path.join(consumerRoot, 'messaging-types.mts'),
+            ]);
+            node([
+                compiler,
+                '--noEmit',
+                '--strict',
+                '--target',
+                'ES2022',
+                '--lib',
+                'ES2022,DOM',
+                '--types',
+                'node',
+                '--module',
+                module,
+                '--moduleResolution',
+                resolution,
+                path.join(consumerRoot, 'reverse-types.mts'),
+            ]);
+        },
+        30_000,
+    );
+});