@walkeros/config 1.0.2 → 1.1.0-next-1771252576264

package/jest/index.mjs

@@ -1,57 +1,75 @@
 import path from 'path';
 import { fileURLToPath } from 'url';
-import { readFileSync } from 'fs';
-
-const isWatchMode = process.argv.includes('--watchAll');
-const packagesDir = path.join(
-  path.dirname(fileURLToPath(import.meta.url)),
-  '..',
-  '..',
-  '..',
-  '/',
-);
-
-function getDirectory(dir) {
-  return path.join(packagesDir, dir);
+import { existsSync, readdirSync, readFileSync, realpathSync } from 'fs';
+
+// Resolve symlinks so import.meta.url always points to the real file path,
+// even when Jest resolves through node_modules symlinks.
+const configDir = realpathSync(path.dirname(fileURLToPath(import.meta.url)));
+const packagesDir = path.join(configDir, '..', '..', '..', '/');
+
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
 
 function getModuleMapper() {
-  if (!isWatchMode) return {};
+  const mapper = {};
+  const scanDir = path.join(packagesDir, 'packages');
 
-  return {
-    '^@walkeros/core$': getDirectory('core/src/'),
-    '^@walkeros/collector$': getDirectory('collector/src/'),
-    '^@walkeros/web-core$': getDirectory('web/core/src/'),
-    '^@walkeros/web-destination-gtag$': getDirectory(
-      'web/destinations/gtag/src/',
-    ),
-    '^@walkeros/web-destination-api$': getDirectory(
-      'web/destinations/api/src/',
-    ),
-    '^@walkeros/web-destination-meta$': getDirectory(
-      'web/destinations/meta/src/',
-    ),
-    '^@walkeros/web-destination-piwikpro$': getDirectory(
-      'web/destinations/piwikpro/src/',
-    ),
-    '^@walkeros/web-destination-plausible$': getDirectory(
-      'web/destinations/plausible/src/',
-    ),
-    '^@walkeros/web-source-browser$': getDirectory('web/sources/browser/src/'),
-    '^@walkeros/web-source-datalayer$': getDirectory(
-      'web/sources/dataLayer/src/',
-    ),
-    '^@walkeros/server-core$': getDirectory('server/core/src/'),
-    '^@walkeros/server-destination-aws$': getDirectory(
-      'server/destinations/aws/src/',
-    ),
-    '^@walkeros/server-destination-gcp$': getDirectory(
-      'server/destinations/gcp/src/',
-    ),
-    '^@walkeros/server-destination-meta$': getDirectory(
-      'server/destinations/meta/src/',
-    ),
-  };
+  function scanForPackages(dir) {
+    if (!existsSync(dir)) return;
+    const entries = readdirSync(dir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (entry.name === 'node_modules' || entry.name === 'dist') continue;
+
+      const fullPath = path.join(dir, entry.name);
+      const pkgJsonPath = path.join(fullPath, 'package.json');
+
+      if (existsSync(pkgJsonPath)) {
+        const pkg = JSON.parse(readFileSync(pkgJsonPath, 'utf8'));
+
+        if (pkg.name?.startsWith('@walkeros/') && existsSync(path.join(fullPath, 'src'))) {
+          // Map root export: @walkeros/core → packages/core/src/
+          mapper[`^${escapeRegex(pkg.name)}$`] = path.join(fullPath, 'src/');
+
+          // Map subpath exports: @walkeros/core/dev → packages/core/src/dev
+          if (pkg.exports) {
+            for (const subpath of Object.keys(pkg.exports)) {
+              if (subpath === '.' || !subpath.startsWith('./')) continue;
+              const subName = subpath.slice(2);
+              const srcFile = path.join(fullPath, 'src', subName);
+              if (
+                existsSync(srcFile + '.ts') ||
+                existsSync(srcFile + '.tsx') ||
+                existsSync(path.join(srcFile, 'index.ts'))
+              ) {
+                mapper[`^${escapeRegex(pkg.name)}/${escapeRegex(subName)}$`] = srcFile;
+              }
+            }
+          }
+        }
+      }
+
+      // Recurse into subdirectories (handles packages/web/core/, packages/server/destinations/api/, etc.)
+      scanForPackages(fullPath);
+    }
+  }
+
+  scanForPackages(path.join(packagesDir, 'packages'));
+
+  if (Object.keys(mapper).length === 0) {
+    throw new Error(
+      `[jest-config] moduleNameMapper is empty — no @walkeros/* packages found.\n` +
+      `  packagesDir: ${packagesDir}\n` +
+      `  scanDir: ${scanDir}\n` +
+      `  scanDir exists: ${existsSync(scanDir)}\n` +
+      `This usually means a stale @walkeros/config copy was loaded from node_modules ` +
+      `instead of the workspace version. Run: npm dedupe @walkeros/config`,
+    );
+  }
+
+  return mapper;
 }
 
 function getGlobals() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@walkeros/config",
-  "version": "1.0.2",
+  "version": "1.1.0-next-1771252576264",
   "type": "module",
   "description": "Shared development configuration for walkerOS packages (TypeScript, ESLint, Jest, tsup)",
   "license": "MIT",
@@ -60,7 +60,6 @@
     "url": "https://github.com/elbwalker/walkerOS/issues"
   },
   "keywords": [
-    "walker",
     "walkerOS",
     "config",
     "typescript",

package/tsconfig/base.json

@@ -18,6 +18,8 @@
     "target": "es2022",
     "allowJs": true,
     "resolveJsonModule": true,
+    "incremental": true,
+    "tsBuildInfoFile": ".tsbuildinfo",
     "sourceMap": true,
     "outDir": "dist",
     "baseUrl": "."

package/tsup/__tests__/toSerializable.test.mjs

@@ -0,0 +1,220 @@
+import { toSerializable } from '../index.mjs';
+
+describe('toSerializable', () => {
+  // Primitives
+  it('passes through strings', () => {
+    expect(toSerializable('hello')).toBe('hello');
+  });
+
+  it('passes through numbers', () => {
+    expect(toSerializable(42)).toBe(42);
+    expect(toSerializable(0)).toBe(0);
+    expect(toSerializable(-1.5)).toBe(-1.5);
+  });
+
+  it('passes through booleans', () => {
+    expect(toSerializable(true)).toBe(true);
+    expect(toSerializable(false)).toBe(false);
+  });
+
+  it('passes through null', () => {
+    expect(toSerializable(null)).toBeNull();
+  });
+
+  it('passes through undefined', () => {
+    expect(toSerializable(undefined)).toBeUndefined();
+  });
+
+  // Functions
+  it('converts functions to $code objects', () => {
+    const fn = () => 'test';
+    const result = toSerializable(fn);
+    expect(result).toEqual({ $code: fn.toString() });
+  });
+
+  it('converts named functions to $code objects', () => {
+    function myFunc(a, b) {
+      return a + b;
+    }
+    const result = toSerializable(myFunc);
+    expect(result).toHaveProperty('$code');
+    expect(result.$code).toContain('myFunc');
+  });
+
+  // Zod schema instances (objects with _def.typeName starting with 'Zod')
+  it('should filter out Zod schema instances', () => {
+    const zodSchema = {
+      parse: (val) => val,
+      safeParse: (val) => ({ success: true, data: val }),
+      _def: { typeName: 'ZodObject' },
+    };
+    expect(toSerializable(zodSchema)).toBeUndefined();
+  });
+
+  it('filters out other Zod types', () => {
+    const zodString = { parse: () => {}, _def: { typeName: 'ZodString' } };
+    expect(toSerializable(zodString)).toBeUndefined();
+  });
+
+  it('filters out Zod 4 instances (have _zod property)', () => {
+    // Zod 4 instances have _zod but no _def.typeName
+    const zod4Schema = {
+      parse: () => {},
+      safeParse: () => {},
+      _def: { type: 'object', shape: {} },
+      _zod: { def: {}, constr: {}, traits: new Set(), bag: {} },
+    };
+    expect(toSerializable(zod4Schema)).toBeUndefined();
+  });
+
+  it('filters out Zod 4 instances from nested objects', () => {
+    const obj = {
+      settings: { type: 'object', properties: { url: { type: 'string' } } },
+      SettingsSchema: {
+        parse: () => {},
+        _zod: { def: {}, constr: {} },
+      },
+      MappingSchema: {
+        parse: () => {},
+        _def: { type: 'object' },
+        _zod: { def: {} },
+      },
+    };
+    const result = toSerializable(obj);
+    expect(result).toEqual({
+      settings: { type: 'object', properties: { url: { type: 'string' } } },
+    });
+    expect(result).not.toHaveProperty('SettingsSchema');
+    expect(result).not.toHaveProperty('MappingSchema');
+  });
+
+  it('should NOT filter out non-Zod objects that have a .parse method', () => {
+    const csvParser = { parse: (str) => str.split(','), data: [1, 2, 3] };
+    const result = toSerializable(csvParser);
+    expect(result).toEqual({ data: [1, 2, 3], parse: { $code: csvParser.parse.toString() } });
+  });
+
+  // Plain objects
+  it('passes through plain objects', () => {
+    const obj = { a: 1, b: 'two', c: true };
+    expect(toSerializable(obj)).toEqual({ a: 1, b: 'two', c: true });
+  });
+
+  it('handles nested objects', () => {
+    const obj = { outer: { inner: { value: 42 } } };
+    expect(toSerializable(obj)).toEqual({ outer: { inner: { value: 42 } } });
+  });
+
+  it('strips Zod instances from nested objects', () => {
+    const obj = {
+      settings: { type: 'object', properties: {} },
+      SettingsSchema: { parse: () => {}, _def: { typeName: 'ZodObject' } },
+    };
+    const result = toSerializable(obj);
+    expect(result).toEqual({
+      settings: { type: 'object', properties: {} },
+    });
+    expect(result).not.toHaveProperty('SettingsSchema');
+  });
+
+  it('converts nested functions to $code', () => {
+    const noop = () => {};
+    const obj = {
+      name: 'test',
+      handler: noop,
+      nested: { callback: noop },
+    };
+    const result = toSerializable(obj);
+    expect(result.name).toBe('test');
+    expect(result.handler).toEqual({ $code: noop.toString() });
+    expect(result.nested.callback).toEqual({ $code: noop.toString() });
+  });
+
+  // Arrays
+  it('passes through arrays of primitives', () => {
+    expect(toSerializable([1, 2, 3])).toEqual([1, 2, 3]);
+  });
+
+  it('replaces Zod instances in arrays with undefined (preserves indices)', () => {
+    const arr = [
+      { name: 'keep' },
+      { parse: () => {}, _def: { typeName: 'ZodString' } },
+      { name: 'also keep' },
+    ];
+    const result = toSerializable(arr);
+    expect(result).toEqual([{ name: 'keep' }, undefined, { name: 'also keep' }]);
+    expect(result).toHaveLength(3);
+  });
+
+  it('converts functions inside arrays', () => {
+    const fn = () => 'test';
+    const result = toSerializable([1, fn, 'three']);
+    expect(result).toEqual([1, { $code: fn.toString() }, 'three']);
+  });
+
+  it('handles nested arrays', () => {
+    const result = toSerializable([[1, 2], [3, 4]]);
+    expect(result).toEqual([[1, 2], [3, 4]]);
+  });
+
+  // Complex/realistic scenario
+  it('handles a realistic dev module export structure', () => {
+    const noop = () => Promise.resolve({ ok: true });
+    const devExports = {
+      env: {
+        init: { sendServer: undefined },
+        standard: { sendServer: noop },
+      },
+      events: {
+        pageView: { event: 'page view', data: { title: 'Home' } },
+      },
+    };
+
+    const result = toSerializable(devExports);
+
+    // sendServer undefined should be stripped (key omitted)
+    expect(result.env.init).toEqual({});
+    // sendServer function should become $code
+    expect(result.env.standard.sendServer).toHaveProperty('$code');
+    expect(result.env.standard.sendServer.$code).toContain('Promise.resolve');
+    // Plain data passes through
+    expect(result.events.pageView).toEqual({
+      event: 'page view',
+      data: { title: 'Home' },
+    });
+  });
+
+  // JSON roundtrip safety
+  it('produces JSON-safe output', () => {
+    const fn = (a) => a * 2;
+    const input = {
+      name: 'test',
+      handler: fn,
+      zodSchema: { parse: () => {}, _def: { typeName: 'ZodObject' } },
+      data: [1, 'two', { nested: true }],
+    };
+
+    const result = toSerializable(input);
+    const json = JSON.stringify(result);
+    const parsed = JSON.parse(json);
+
+    expect(parsed.name).toBe('test');
+    expect(parsed.handler.$code).toContain('a * 2');
+    expect(parsed).not.toHaveProperty('zodSchema');
+    expect(parsed.data).toEqual([1, 'two', { nested: true }]);
+  });
+
+  // Edge cases
+  it('handles empty objects', () => {
+    expect(toSerializable({})).toEqual({});
+  });
+
+  it('handles empty arrays', () => {
+    expect(toSerializable([])).toEqual([]);
+  });
+
+  it('does not treat objects with non-function .parse as Zod', () => {
+    const obj = { parse: 'not a function', value: 42 };
+    expect(toSerializable(obj)).toEqual({ parse: 'not a function', value: 42 });
+  });
+});

package/tsup/index.mjs

@@ -1,6 +1,7 @@
 import { defineConfig } from 'tsup';
-import { readFileSync } from 'fs';
-import { resolve } from 'path';
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
+import { resolve, join } from 'path';
+import { pathToFileURL } from 'url';
 
 const baseConfig = {
   entry: ['src/index.ts'],
@@ -73,11 +74,133 @@ const buildES5 = (customConfig = {}) => ({
   ...customConfig,
 });
 
+/**
+ * Deep-clone a value for JSON serialization.
+ *
+ * Conventions:
+ * - Functions → { $code: fn.toString() } — serialized source for documentation, not executable
+ * - Zod instances → filtered out (returns undefined)
+ *   Zod 3: detected via _def.typeName starting with 'Zod'
+ *   Zod 4: detected via _zod property
+ * - Everything else → recursively passed through
+ */
+const toSerializable = (value) => {
+  if (value === null || value === undefined) return value;
+  if (typeof value === 'function') return { $code: value.toString() };
+  if (
+    typeof value === 'object' &&
+    (value._def?.typeName?.startsWith?.('Zod') || '_zod' in value)
+  )
+    return undefined;
+  if (Array.isArray(value)) {
+    return value.map((item) => toSerializable(item));
+  }
+  if (typeof value === 'object') {
+    const result = {};
+    for (const [key, val] of Object.entries(value)) {
+      const serialized = toSerializable(val);
+      if (serialized !== undefined) result[key] = serialized;
+    }
+    return result;
+  }
+  return value;
+};
+
+// Dev build: builds src/dev.ts and generates walkerOS.json
+const buildDev = (customConfig = {}) => {
+  const { onSuccess: customOnSuccess, ...restConfig } = customConfig;
+
+  const modulesConfig = buildModules({
+    entry: ['src/dev.ts'],
+    ...restConfig,
+  });
+
+  return {
+    ...modulesConfig,
+    async onSuccess() {
+      const cwd = process.cwd();
+      const packagePath = resolve(cwd, 'package.json');
+      let pkg = { name: 'unknown', version: '0.0.0' };
+      try {
+        pkg = JSON.parse(readFileSync(packagePath, 'utf8'));
+      } catch (error) {
+        console.warn('[buildDev] Could not read package.json:', error.message);
+      }
+
+      // Check the built module exists
+      const devMjsPath = resolve(cwd, 'dist/dev.mjs');
+      if (!existsSync(devMjsPath)) {
+        console.warn('[buildDev] dist/dev.mjs not found, skipping walkerOS.json generation');
+        return;
+      }
+
+      // Import the built module (cache-bust for watch mode rebuilds)
+      const devModulePath = pathToFileURL(devMjsPath).href;
+      let devModule;
+      try {
+        devModule = await import(`${devModulePath}?t=${Date.now()}`);
+      } catch (error) {
+        console.warn(
+          `[buildDev] Could not import dist/dev.mjs: ${error.message}. Skipping walkerOS.json generation`,
+        );
+        return;
+      }
+
+      // Extract schemas (Zod instances filtered by toSerializable)
+      const schemas = toSerializable(devModule.schemas || {}) || {};
+
+      // Extract examples (convert functions to $code strings)
+      const rawExamples = devModule.examples || {};
+      const examples = toSerializable(rawExamples) || {};
+
+      // Read type and platform from package.json walkerOS field
+      const walkerOS = pkg.walkerOS || {};
+      const meta = { package: pkg.name, version: pkg.version };
+      if (walkerOS.type) meta.type = walkerOS.type;
+      if (walkerOS.platform) meta.platform = walkerOS.platform;
+
+      const output = { $meta: meta, schemas, examples };
+
+      // Validate
+      if (Object.keys(schemas).length === 0) {
+        console.warn('[buildDev] Warning: schemas is empty');
+      }
+
+      // Verify valid JSON roundtrip
+      const jsonString = JSON.stringify(output, null, 2);
+      try {
+        JSON.parse(jsonString);
+      } catch (error) {
+        console.error(
+          '[buildDev] Error: output is not valid JSON:',
+          error.message,
+        );
+        return;
+      }
+
+      // Write to dist/walkerOS.json
+      const outDir = resolve(cwd, 'dist');
+      mkdirSync(outDir, { recursive: true });
+      writeFileSync(join(outDir, 'walkerOS.json'), jsonString);
+      console.log(
+        `[buildDev] Generated dist/walkerOS.json for ${pkg.name}@${pkg.version}`,
+      );
+
+      // Run custom onSuccess if provided
+      if (typeof customOnSuccess === 'function') {
+        await customOnSuccess();
+      }
+    },
+  };
+};
+
 export {
   baseConfig,
   buildModules,
   buildExamples,
   buildBrowser,
   buildES5,
+  buildDev,
+  toSerializable,
   defineConfig,
 };