@dainprotocol/cli 1.2.26 → 1.2.30

package/dist/__tests__/build.test.js

@@ -0,0 +1,289 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var path_1 = __importDefault(require("path"));
+/**
+ * Build command tests - focusing on WASM detection, esbuild config, and static files
+ */
+describe('build.ts', function () {
+    describe('findWasmFiles logic', function () {
+        // Test the WASM file filtering logic
+        function shouldIncludeWasmFile(fullPath) {
+            // Only include WASM files in dist/nodejs directories (Node.js bindings)
+            return fullPath.includes('/dist/') || fullPath.includes('/build/');
+        }
+        test('includes WASM files in /dist/ directories', function () {
+            expect(shouldIncludeWasmFile('/node_modules/package/dist/module.wasm')).toBe(true);
+            expect(shouldIncludeWasmFile('/node_modules/@scope/pkg/dist/nodejs/binding.wasm')).toBe(true);
+        });
+        test('includes WASM files in /build/ directories', function () {
+            expect(shouldIncludeWasmFile('/node_modules/package/build/Release/native.wasm')).toBe(true);
+        });
+        test('excludes WASM files in root of package', function () {
+            expect(shouldIncludeWasmFile('/node_modules/package/module.wasm')).toBe(false);
+        });
+        test('excludes WASM files in src directories', function () {
+            expect(shouldIncludeWasmFile('/node_modules/package/src/module.wasm')).toBe(false);
+        });
+        test('excludes WASM files in test directories', function () {
+            expect(shouldIncludeWasmFile('/node_modules/package/test/fixture.wasm')).toBe(false);
+        });
+    });
+    describe('directory scanning exclusions', function () {
+        // Test the directories that should be skipped
+        function shouldSkipDirectory(name) {
+            return name === '.bin' || name === '.cache';
+        }
+        test('skips .bin directory', function () {
+            expect(shouldSkipDirectory('.bin')).toBe(true);
+        });
+        test('skips .cache directory', function () {
+            expect(shouldSkipDirectory('.cache')).toBe(true);
+        });
+        test('does not skip regular directories', function () {
+            expect(shouldSkipDirectory('dist')).toBe(false);
+            expect(shouldSkipDirectory('src')).toBe(false);
+            expect(shouldSkipDirectory('@scope')).toBe(false);
+        });
+        test('does not skip .pnpm store (scanned for packages)', function () {
+            expect(shouldSkipDirectory('.pnpm')).toBe(false);
+        });
+    });
+    describe('copyWasmDependencies logic', function () {
+        // Test the bundle scanning for WASM references
+        function isWasmReferencedInBundle(wasmName, bundleContent) {
+            return bundleContent.includes(wasmName);
+        }
+        test('detects WASM file references in bundle', function () {
+            var bundle = "\n        const wasmPath = require.resolve(\"zstd-codec/zstddec.wasm\");\n        const decoder = new Decoder(wasmPath);\n      ";
+            expect(isWasmReferencedInBundle('zstddec.wasm', bundle)).toBe(true);
+        });
+        test('does not match partial WASM names', function () {
+            var bundle = 'const zstddec_module = require("module");';
+            expect(isWasmReferencedInBundle('zstddec.wasm', bundle)).toBe(false);
+        });
+        test('handles multiple WASM references', function () {
+            var bundle = "\n        require(\"libzstd.wasm\");\n        require(\"wasm_exec.wasm\");\n      ";
+            expect(isWasmReferencedInBundle('libzstd.wasm', bundle)).toBe(true);
+            expect(isWasmReferencedInBundle('wasm_exec.wasm', bundle)).toBe(true);
+            expect(isWasmReferencedInBundle('other.wasm', bundle)).toBe(false);
+        });
+    });
+    describe('runtime configuration', function () {
+        function getNodeBuildOptions(watch) {
+            return {
+                platform: 'node',
+                target: 'es2020',
+                minify: !watch,
+            };
+        }
+        function getWorkersBuildOptions() {
+            return {
+                format: 'esm',
+                target: 'esnext',
+                conditions: ['worker', 'workerd', 'browser'],
+                outExtension: { '.js': '.mjs' },
+            };
+        }
+        test('node runtime: platform is node', function () {
+            var options = getNodeBuildOptions(false);
+            expect(options.platform).toBe('node');
+        });
+        test('node runtime: minify when not watching', function () {
+            expect(getNodeBuildOptions(false).minify).toBe(true);
+            expect(getNodeBuildOptions(true).minify).toBe(false);
+        });
+        test('node runtime: targets ES2020', function () {
+            expect(getNodeBuildOptions(false).target).toBe('es2020');
+        });
+        test('workers runtime: uses ESM format', function () {
+            var options = getWorkersBuildOptions();
+            expect(options.format).toBe('esm');
+        });
+        test('workers runtime: targets esnext', function () {
+            var options = getWorkersBuildOptions();
+            expect(options.target).toBe('esnext');
+        });
+        test('workers runtime: has worker conditions', function () {
+            var options = getWorkersBuildOptions();
+            expect(options.conditions).toContain('worker');
+            expect(options.conditions).toContain('workerd');
+            expect(options.conditions).toContain('browser');
+        });
+        test('workers runtime: outputs .mjs files', function () {
+            var _a;
+            var options = getWorkersBuildOptions();
+            expect((_a = options.outExtension) === null || _a === void 0 ? void 0 : _a['.js']).toBe('.mjs');
+        });
+        test('runtime selection falls back to config then node', function () {
+            function resolveRuntime(optionsRuntime, configRuntime) {
+                return optionsRuntime || configRuntime || 'node';
+            }
+            expect(resolveRuntime('workers', 'node')).toBe('workers');
+            expect(resolveRuntime(undefined, 'workers')).toBe('workers');
+            expect(resolveRuntime(undefined, undefined)).toBe('node');
+        });
+    });
+    describe('output directory handling', function () {
+        test('resolves out-dir from config', function () {
+            var cwd = '/project';
+            var config = { 'out-dir': 'dist' };
+            var outDir = path_1.default.join(cwd, config['out-dir']);
+            expect(outDir).toBe('/project/dist');
+        });
+        test('defaults to "build" when not specified', function () {
+            var cwd = '/project';
+            var config = {};
+            var outDir = path_1.default.join(cwd, config['out-dir'] || 'build');
+            expect(outDir).toBe('/project/build');
+        });
+        test('watch mode uses .dain directory', function () {
+            var cwd = '/project';
+            var dainDir = path_1.default.join(cwd, '.dain');
+            var outDir = path_1.default.join(cwd, 'build');
+            function getTargetDir(isWatch) {
+                return isWatch ? dainDir : outDir;
+            }
+            expect(getTargetDir(true)).toBe('/project/.dain');
+            expect(getTargetDir(false)).toBe('/project/build');
+        });
+    });
+    describe('static files handling', function () {
+        test('resolves static-dir from config', function () {
+            var cwd = '/project';
+            var config = { 'static-dir': 'assets' };
+            var staticDir = path_1.default.join(cwd, config['static-dir']);
+            expect(staticDir).toBe('/project/assets');
+        });
+        test('defaults to "static" when not specified', function () {
+            var cwd = '/project';
+            var config = {};
+            var staticDir = config['static-dir']
+                ? path_1.default.join(cwd, config['static-dir'])
+                : path_1.default.join(cwd, 'static');
+            expect(staticDir).toBe('/project/static');
+        });
+        test('static output goes to targetDir/static', function () {
+            var targetDir = '/project/build';
+            var staticOutDir = path_1.default.join(targetDir, 'static');
+            expect(staticOutDir).toBe('/project/build/static');
+        });
+    });
+    describe('entry point handling', function () {
+        test('uses main-file from config', function () {
+            var config = { 'main-file': 'src/index.ts' };
+            expect(config['main-file']).toBe('src/index.ts');
+        });
+        test('entry point is always an array', function () {
+            var config = { 'main-file': 'src/server.ts' };
+            var entryPoints = [config['main-file']];
+            expect(Array.isArray(entryPoints)).toBe(true);
+            expect(entryPoints).toEqual(['src/server.ts']);
+        });
+    });
+    describe('WASM file extension detection', function () {
+        test('identifies .wasm files', function () {
+            var isWasm = function (filename) { return filename.endsWith('.wasm'); };
+            expect(isWasm('module.wasm')).toBe(true);
+            expect(isWasm('binding.wasm')).toBe(true);
+            expect(isWasm('decoder.WASM')).toBe(false); // Case sensitive
+            expect(isWasm('module.js')).toBe(false);
+            expect(isWasm('wasm.js')).toBe(false); // "wasm" in name, not extension
+        });
+    });
+    describe('path operations', function () {
+        test('basename extracts filename from path', function () {
+            expect(path_1.default.basename('/node_modules/pkg/dist/module.wasm')).toBe('module.wasm');
+            expect(path_1.default.basename('/long/nested/path/file.wasm')).toBe('file.wasm');
+        });
+        test('join constructs destination path', function () {
+            var outDir = '/project/build';
+            var wasmName = 'decoder.wasm';
+            var destPath = path_1.default.join(outDir, wasmName);
+            expect(destPath).toBe('/project/build/decoder.wasm');
+        });
+    });
+    describe('bundle path calculation', function () {
+        test('calculates bundle path for standard build', function () {
+            var targetDir = '/project/build';
+            var bundlePath = path_1.default.join(targetDir, 'index.js');
+            expect(bundlePath).toBe('/project/build/index.js');
+        });
+        test('calculates bundle path for watch mode', function () {
+            var dainDir = '/project/.dain';
+            var bundlePath = path_1.default.join(dainDir, 'index.js');
+            expect(bundlePath).toBe('/project/.dain/index.js');
+        });
+    });
+    describe('error handling', function () {
+        test('unsupported runtime throws error', function () {
+            function validateRuntime(runtime) {
+                if (runtime !== 'node' && runtime !== 'workers') {
+                    throw new Error("Unsupported runtime: ".concat(runtime));
+                }
+            }
+            expect(function () { return validateRuntime('node'); }).not.toThrow();
+            expect(function () { return validateRuntime('workers'); }).not.toThrow();
+            expect(function () { return validateRuntime('deno'); }).toThrow('Unsupported runtime: deno');
+            expect(function () { return validateRuntime('bun'); }).toThrow('Unsupported runtime: bun');
+        });
+    });
+    describe('sourcemap generation', function () {
+        test('sourcemap is always enabled', function () {
+            var buildOptions = { sourcemap: true };
+            expect(buildOptions.sourcemap).toBe(true);
+        });
+    });
+    describe('bundle configuration', function () {
+        test('bundle option is always true', function () {
+            var buildOptions = { bundle: true };
+            expect(buildOptions.bundle).toBe(true);
+        });
+    });
+});
+describe('WASM detection patterns', function () {
+    // Common WASM packages that should be detected
+    var commonWasmPackages = [
+        '@noble/ed25519',
+        '@solana/buffer-layout',
+        'zstd-codec',
+        'zstddec',
+        'wasm-pack',
+    ];
+    describe('common package paths', function () {
+        test.each(commonWasmPackages)('detects %s dist WASM files', function (pkg) {
+            var distPath = "/node_modules/".concat(pkg, "/dist/module.wasm");
+            expect(distPath.includes('/dist/')).toBe(true);
+        });
+    });
+    describe('pnpm store paths', function () {
+        test('handles .pnpm versioned paths', function () {
+            var pnpmPath = '/node_modules/.pnpm/zstd-codec@0.1.5/node_modules/zstd-codec/dist/zstddec.wasm';
+            expect(pnpmPath.includes('/dist/')).toBe(true);
+            expect(pnpmPath.endsWith('.wasm')).toBe(true);
+        });
+        test('handles scoped packages in pnpm', function () {
+            var pnpmPath = '/node_modules/.pnpm/@solana+web3.js@1.95.0/node_modules/@solana/web3.js/dist/binding.wasm';
+            expect(pnpmPath.includes('/dist/')).toBe(true);
+        });
+    });
+});
+describe('build process exit behavior', function () {
+    test('non-watch, non-deploy mode exits with 0', function () {
+        var options = { watch: false, deploy: false };
+        var shouldExit = !options.watch && !options.deploy;
+        expect(shouldExit).toBe(true);
+    });
+    test('watch mode does not exit', function () {
+        var options = { watch: true, deploy: false };
+        var shouldExit = !options.watch && !options.deploy;
+        expect(shouldExit).toBe(false);
+    });
+    test('deploy mode does not exit', function () {
+        var options = { watch: false, deploy: true };
+        var shouldExit = !options.watch && !options.deploy;
+        expect(shouldExit).toBe(false);
+    });
+});

package/dist/__tests__/deploy.test.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var utils_1 = require("../utils");
+// Mock fs-extra before importing
+jest.mock('fs-extra', function () { return ({
+    readFile: jest.fn(),
+    readdir: jest.fn(),
+    existsSync: jest.fn(),
+    readFileSync: jest.fn(),
+}); });
+// Test the env parsing logic directly
+describe('loadEnvVariables', function () {
+    // Extract the parsing logic for testing
+    test('parses simple key=value pairs', function () {
+        var content = "FOO=bar\nBAZ=qux";
+        var result = (0, utils_1.parseEnvContent)(content);
+        expect(result).toEqual([
+            { name: 'FOO', value: 'bar' },
+            { name: 'BAZ', value: 'qux' },
+        ]);
+    });
+    test('handles values with = signs (like base64)', function () {
+        var content = "API_KEY=sk_test_abc123==\nSECRET=a=b=c=d";
+        var result = (0, utils_1.parseEnvContent)(content);
+        expect(result).toEqual([
+            { name: 'API_KEY', value: 'sk_test_abc123==' },
+            { name: 'SECRET', value: 'a=b=c=d' },
+        ]);
+    });
+    test('ignores comment lines', function () {
+        var content = "# This is a comment\nFOO=bar\n# Another comment\nBAZ=qux";
+        var result = (0, utils_1.parseEnvContent)(content);
+        expect(result).toEqual([
+            { name: 'FOO', value: 'bar' },
+            { name: 'BAZ', value: 'qux' },
+        ]);
+    });
+    test('ignores empty lines', function () {
+        var content = "FOO=bar\n\nBAZ=qux\n\n";
+        var result = (0, utils_1.parseEnvContent)(content);
+        expect(result).toEqual([
+            { name: 'FOO', value: 'bar' },
+            { name: 'BAZ', value: 'qux' },
+        ]);
+    });
+    test('removes surrounding quotes from values', function () {
+        var content = "FOO=\"bar\"\nBAZ='qux'\nSINGLE=\"quoted value\"";
+        var result = (0, utils_1.parseEnvContent)(content);
+        expect(result).toEqual([
+            { name: 'FOO', value: 'bar' },
+            { name: 'BAZ', value: 'qux' },
+            { name: 'SINGLE', value: 'quoted value' },
+        ]);
+    });
+    test('handles whitespace around = sign', function () {
+        var content = "  FOO  =  bar\n  BAZ=qux";
+        var result = (0, utils_1.parseEnvContent)(content);
+        expect(result).toEqual([
+            { name: 'FOO', value: 'bar' },
+            { name: 'BAZ', value: 'qux' },
+        ]);
+    });
+    test('skips lines without = sign', function () {
+        var content = "FOO=bar\nINVALID LINE\nBAZ=qux";
+        var result = (0, utils_1.parseEnvContent)(content);
+        expect(result).toEqual([
+            { name: 'FOO', value: 'bar' },
+            { name: 'BAZ', value: 'qux' },
+        ]);
+    });
+    test('skips lines with empty name or value', function () {
+        var content = "=bar\nFOO=\nVALID=value";
+        var result = (0, utils_1.parseEnvContent)(content);
+        expect(result).toEqual([
+            { name: 'VALID', value: 'value' },
+        ]);
+    });
+    test('handles complex production-like env file', function () {
+        var content = "# Production environment\nDATABASE_URL=postgresql://user:pass@host:5432/db?schema=public\nJWT_SECRET=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ\nREDIS_URL=\"redis://localhost:6379\"\nAPI_KEY='sk_live_abc123=='\n\n# Comment in the middle\nEMPTY_LINE_AFTER=true";
+        var result = (0, utils_1.parseEnvContent)(content);
+        expect(result).toHaveLength(5);
+        expect(result[0].name).toBe('DATABASE_URL');
+        expect(result[0].value).toContain('postgresql://');
+        expect(result[1].name).toBe('JWT_SECRET');
+        expect(result[1].value).toContain('eyJ');
+        expect(result[2].value).toBe('redis://localhost:6379');
+        expect(result[3].value).toBe('sk_live_abc123==');
+    });
+});
+describe('fetchWithTimeout', function () {
+    test('AbortController pattern is correct', function () {
+        // Test that our timeout pattern is implemented correctly
+        var controller = new AbortController();
+        // Signal starts as not aborted
+        expect(controller.signal.aborted).toBe(false);
+        // Abort changes the signal
+        controller.abort();
+        expect(controller.signal.aborted).toBe(true);
+    });
+    test('setTimeout + AbortController integration', function () {
+        jest.useFakeTimers();
+        var controller = new AbortController();
+        var timeoutMs = 100;
+        // Set up timeout to abort
+        var timeoutId = setTimeout(function () { return controller.abort(); }, timeoutMs);
+        expect(controller.signal.aborted).toBe(false);
+        // Advance time past timeout
+        jest.advanceTimersByTime(150);
+        expect(controller.signal.aborted).toBe(true);
+        clearTimeout(timeoutId);
+        jest.useRealTimers();
+    });
+    test('clearTimeout prevents abort', function () {
+        jest.useFakeTimers();
+        var controller = new AbortController();
+        var timeoutMs = 100;
+        var timeoutId = setTimeout(function () { return controller.abort(); }, timeoutMs);
+        // Clear before timeout
+        clearTimeout(timeoutId);
+        // Advance time past what would have been the timeout
+        jest.advanceTimersByTime(200);
+        // Should NOT be aborted since we cleared the timeout
+        expect(controller.signal.aborted).toBe(false);
+        jest.useRealTimers();
+    });
+});