zero-com 1.6.5 → 1.7.1

package/.claude/settings.local.json

@@ -2,7 +2,8 @@
   "permissions": {
     "allow": [
       "Bash(npm run build:*)",
-      "Bash(npm test)"
+      "Bash(npm test)",
+      "Bash(grep:*)"
     ]
   }
 }

package/README.md

@@ -7,6 +7,7 @@ The 0 bytes utility for transparently communicating client and server in full-st
 - [Usage](#usage)
 - [Transport layer](#transport-layer)
 - [Context](#context)
+- [Server-to-Server Calls](#server-to-server-calls)
 - [Plugin options](#plugin-options)
 - [Complete Example](#complete-example)
 
@@ -57,7 +58,7 @@ Server side
 // server/phones.ts
 import { func } from 'zero-com';
 
-export const getPhones = func(async () => { 
+export const getPhones = func(async () => {
   // ...
 })
 ```
@@ -100,8 +101,8 @@ On the server-side, you need to create a handler that receives messages from the
 // server/api.js
 import { handle } from 'zero-com';
 
-const someCustomHandler = async (message) => {
-  return await handle(message.funcId, null, message.params);
+const someCustomHandler = async (message, ctx) => {
+  return await handle(message.funcId, ctx, message.params);
 };
 
 // Example of how to use the handler with an Express server
@@ -112,7 +113,8 @@ app.use(express.json());
 
 app.post('/api', async (req, res) => {
   try {
-    const result = await someCustomHandler(req.body);
+    const ctx = { req, res };
+    const result = await someCustomHandler(req.body, ctx);
     res.json(result);
   } catch (error) {
     res.status(500).json({ error: error.message });
@@ -126,42 +128,90 @@ app.listen(8000, () => {
 
 ## Context
 
-Often you want to pass a context-related object to the server functions to have access to data like the request, response, session, etc. Zero-com provides a simple way to do this.
+Often you want to access context-related data in your server functions, such as the request, response, session, etc. Zero-com provides a simple way to do this using the `context()` function.
 
-### Passing Context to Server Functions
+### Accessing Context in Server Functions
 
-To pass context to a server function, you need to wrap the function in `func` and type the first parameter as `context`. The plugin detects this type and handles it accordingly.
+To access context in a server function, call the `context<T>()` function inside your function body. The context is automatically available when the function is called via `handle()`.
 
 ```typescript
 // server/api/phones.ts
 import { func, context } from 'zero-com';
 
 type MyContext = {
-  request: any
+  req: any;
+  res: any;
+  userId: string;
 }
 
-export const getPhones = func(async (ctx: context<MyContext>, name: string) => {
-  // ctx is the context object passed from the server
-  console.log(ctx.request.headers);
+export const getPhones = func(async (name: string) => {
+  // Get the context inside the function
+  const ctx = context<MyContext>();
+
+  console.log('User:', ctx.userId);
+  console.log('Headers:', ctx.req.headers);
+
   // ... your code
 });
 ```
 
 ### Providing Context on the Server
 
-You can pass the context to `handle` when you execute the server function.
+Pass the context as the second argument to `handle()`. The context will be available to the function and any nested server function calls.
 
 ```javascript
 // server/api.js
 import { handle } from 'zero-com';
 
-const myHandler = (request, response, message) => {
-  const ctx = { request, response };
-  // pass context on exec
-  return handle(message.funcId, ctx, message.params);
-};
+app.post('/api', async (req, res) => {
+  const { funcId, params } = req.body;
+
+  // Create context with request data
+  const ctx = {
+    req,
+    res,
+    userId: req.headers['x-user-id']
+  };
+
+  // Pass context to handle - it will be available via context()
+  const result = await handle(funcId, ctx, params);
+  res.json(result);
+});
+```
+
+## Server-to-Server Calls
+
+When one server function calls another server function, the call bypasses the transport layer and executes directly. Context is automatically propagated to nested calls.
+
+```typescript
+// server/api/user.ts
+import { func, context } from 'zero-com';
+
+export const getFirstName = func(async () => {
+  const ctx = context<{ userId: string }>();
+  // ... fetch first name from database
+  return 'John';
+});
+
+// server/api/profile.ts
+import { func, context } from 'zero-com';
+import { getFirstName } from './user';
+
+export const getFullName = func(async (lastName: string) => {
+  // This calls getFirstName directly (no transport layer)
+  // Context is automatically propagated
+  const firstName = await getFirstName();
+  return `${firstName} ${lastName}`;
+});
 ```
 
+When `getFullName` is called from the client:
+1. The call goes through the transport layer to the server
+2. `handle()` sets up the context
+3. `getFullName` executes and calls `getFirstName`
+4. `getFirstName` executes directly (no transport) with the same context
+5. Both functions can access `context()` with the same data
+
 ## Plugin options
 
 | Option      | Type      | Description                                                                 |
@@ -225,11 +275,15 @@ call(async (funcId, params) => {
 import { func, context } from 'zero-com';
 
 type Context = {
-  req: any,
-  res: any
+  req: any;
+  res: any;
 }
 
-export const getPhones = func(async (ctx: context<Context>, name: string) => {
+export const getPhones = func(async (name: string) => {
+  // Access context when needed
+  const ctx = context<Context>();
+  console.log('Request from:', ctx.req.ip);
+
   // In a real application, you would fetch this from a database
   const allPhones = [
     { name: 'iPhone 13', brand: 'Apple' },

package/lib/common.d.ts

@@ -12,15 +12,14 @@ export type ServerFuncInfo = {
     funcId: string;
     filePath: string;
     exportName: string;
-    requireContext: boolean;
 };
 export type ServerFuncRegistry = Map<string, Map<string, ServerFuncInfo>>;
 export declare const ZERO_COM_CLIENT_CALL = "ZERO_COM_CLIENT_CALL";
 export declare const ZERO_COM_SERVER_REGISTRY = "ZERO_COM_SERVER_REGISTRY";
+export declare const ZERO_COM_CONTEXT_STORAGE = "ZERO_COM_CONTEXT_STORAGE";
 export declare const SERVER_FUNCTION_WRAPPER_NAME = "func";
 export declare const HANDLE_NAME = "handle";
 export declare const CALL_NAME = "call";
-export declare const CONTEXT_TYPE_NAME = "context";
 export declare const LIBRARY_NAME = "zero-com";
 export declare const FILE_EXTENSIONS: string[];
 export declare const formatFuncIdName: (funcName: string, filePath: string, line: number) => string;

package/lib/common.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyReplacements = exports.emitToJs = exports.transformSourceFile = exports.appendRegistryCode = exports.applyReplacementsWithMap = exports.collectFuncCallReplacements = exports.collectSendCallReplacements = exports.collectHandleCallReplacements = exports.collectCallSiteReplacements = exports.getImportedServerFunctions = exports.buildRegistry = exports.createProject = exports.resolveFilePath = exports.isFromLibrary = exports.getReplacements = exports.generateCompilationId = exports.formatFuncIdName = exports.FILE_EXTENSIONS = exports.LIBRARY_NAME = exports.CONTEXT_TYPE_NAME = exports.CALL_NAME = exports.HANDLE_NAME = exports.SERVER_FUNCTION_WRAPPER_NAME = exports.ZERO_COM_SERVER_REGISTRY = exports.ZERO_COM_CLIENT_CALL = void 0;
+exports.applyReplacements = exports.emitToJs = exports.transformSourceFile = exports.appendRegistryCode = exports.applyReplacementsWithMap = exports.collectFuncCallReplacements = exports.collectSendCallReplacements = exports.collectHandleCallReplacements = exports.collectCallSiteReplacements = exports.getImportedServerFunctions = exports.buildRegistry = exports.createProject = exports.resolveFilePath = exports.isFromLibrary = exports.getReplacements = exports.generateCompilationId = exports.formatFuncIdName = exports.FILE_EXTENSIONS = exports.LIBRARY_NAME = exports.CALL_NAME = exports.HANDLE_NAME = exports.SERVER_FUNCTION_WRAPPER_NAME = exports.ZERO_COM_CONTEXT_STORAGE = exports.ZERO_COM_SERVER_REGISTRY = exports.ZERO_COM_CLIENT_CALL = void 0;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const magic_string_1 = __importDefault(require("magic-string"));
@@ -11,10 +11,10 @@ const ts_morph_1 = require("ts-morph");
 // Constants
 exports.ZERO_COM_CLIENT_CALL = 'ZERO_COM_CLIENT_CALL';
 exports.ZERO_COM_SERVER_REGISTRY = 'ZERO_COM_SERVER_REGISTRY';
+exports.ZERO_COM_CONTEXT_STORAGE = 'ZERO_COM_CONTEXT_STORAGE';
 exports.SERVER_FUNCTION_WRAPPER_NAME = 'func';
 exports.HANDLE_NAME = 'handle';
 exports.CALL_NAME = 'call';
-exports.CONTEXT_TYPE_NAME = 'context';
 exports.LIBRARY_NAME = 'zero-com';
 exports.FILE_EXTENSIONS = ['', '.ts', '.tsx', '.js', '.jsx', '.mjs'];
 const formatFuncIdName = (funcName, filePath, line) => {
@@ -25,7 +25,8 @@ const generateCompilationId = () => String(Math.floor(Math.random() * 1000000));
 exports.generateCompilationId = generateCompilationId;
 const getReplacements = (compilationId) => [
     { target: exports.ZERO_COM_CLIENT_CALL, replacement: `__ZERO_COM_CLIENT_CALL_${compilationId}` },
-    { target: exports.ZERO_COM_SERVER_REGISTRY, replacement: `__ZERO_COM_SERVER_REGISTRY_${compilationId}` }
+    { target: exports.ZERO_COM_SERVER_REGISTRY, replacement: `__ZERO_COM_SERVER_REGISTRY_${compilationId}` },
+    { target: exports.ZERO_COM_CONTEXT_STORAGE, replacement: `__ZERO_COM_CONTEXT_STORAGE_${compilationId}` }
 ];
 exports.getReplacements = getReplacements;
 // Utilities
@@ -98,7 +99,6 @@ const buildRegistry = (contextDir, registry) => {
 };
 exports.buildRegistry = buildRegistry;
 const scanFileForServerFunctions = (filePath, contextDir, registry) => {
-    var _a;
     const sourceFile = (0, exports.createProject)().createSourceFile(filePath, fs_1.default.readFileSync(filePath, 'utf8'), { overwrite: true });
     const fileRegistry = new Map();
     for (const decl of sourceFile.getVariableDeclarations()) {
@@ -116,14 +116,11 @@ const scanFileForServerFunctions = (filePath, contextDir, registry) => {
         const args = callExpr.getArguments();
         if (args.length !== 1 || args[0].getKind() !== ts_morph_1.SyntaxKind.ArrowFunction)
             continue;
-        const params = args[0].getParameters();
-        const requireContext = params.length > 0 && ((_a = params[0].getTypeNode()) === null || _a === void 0 ? void 0 : _a.getText().startsWith(exports.CONTEXT_TYPE_NAME)) || false;
         const exportName = decl.getName();
         fileRegistry.set(exportName, {
             funcId: (0, exports.formatFuncIdName)(exportName, path_1.default.relative(contextDir, filePath), decl.getStartLineNumber()),
             filePath,
             exportName,
-            requireContext,
         });
     }
     if (fileRegistry.size > 0)
@@ -191,10 +188,11 @@ const collectHandleCallReplacements = (sourceFile) => {
         const funcId = args[0].getText();
         const ctx = args[1].getText();
         const argsArray = args[2].getText();
+        // Use contextStorage.run() to make context available via context() calls
         replacements.push({
             start: callExpr.getStart(),
             end: callExpr.getEnd(),
-            content: `((__fn) => __fn.requireContext ? __fn(${ctx}, ...${argsArray}) : __fn(...${argsArray}))(globalThis.${exports.ZERO_COM_SERVER_REGISTRY}[${funcId}])`
+            content: `globalThis.${exports.ZERO_COM_CONTEXT_STORAGE}.run(${ctx}, () => globalThis.${exports.ZERO_COM_SERVER_REGISTRY}[${funcId}](...${argsArray}))`
         });
     });
     return replacements;
@@ -260,13 +258,9 @@ const applyReplacementsWithMap = (source, replacements, filePath) => {
 };
 exports.applyReplacementsWithMap = applyReplacementsWithMap;
 const appendRegistryCode = (sourceFile, fileRegistry) => {
-    // Generate registration code for each server function.
-    // We set requireContext based on compile-time analysis of the function's first parameter type.
-    // If the first param is context<T>, requireContext = true, otherwise false.
-    // This allows handle() at runtime to know whether to inject the context as the first argument.
+    // Generate registration code for each server function
     const registrations = Array.from(fileRegistry.values())
-        .map(info => `globalThis.${exports.ZERO_COM_SERVER_REGISTRY}['${info.funcId}'] = ${info.exportName};\n` +
-        `${info.exportName}.requireContext = ${info.requireContext};`)
+        .map(info => `globalThis.${exports.ZERO_COM_SERVER_REGISTRY}['${info.funcId}'] = ${info.exportName};`)
         .join('\n');
     return `${sourceFile.getFullText()}
 if (!globalThis.${exports.ZERO_COM_SERVER_REGISTRY}) globalThis.${exports.ZERO_COM_SERVER_REGISTRY} = Object.create(null);

package/lib/runtime.d.ts

@@ -2,14 +2,13 @@ declare global {
     var ZERO_COM_SERVER_REGISTRY: {
         [funcId: string]: (...args: any[]) => any;
     };
-    var ZERO_COM_CLIENT_CALL: (funcId: string, args: any[]) => Promise<any>;
+    var ZERO_COM_CLIENT_CALL: (funcId: string, args: any[]) => any;
+    var ZERO_COM_CONTEXT_STORAGE: {
+        run: <T>(ctx: any, fn: () => T) => T;
+        getStore: () => any;
+    } | undefined;
 }
-declare const contextBrand: unique symbol;
-export type context<T = unknown> = T & {
-    readonly [contextBrand]: never;
-};
-type RemoveContextParam<F> = F extends (ctx: infer C, ...args: infer A) => infer R ? C extends context<unknown> ? (...args: A) => R : F : F;
-export declare function func<F extends (...args: any[]) => any>(fn: F): RemoveContextParam<F>;
+export declare function context<T = unknown>(): T;
+export declare function func<F extends (...args: any[]) => any>(fn: F): F;
 export declare const handle: (funcId: string, ctx: any, args: any[]) => any;
-export declare const call: (fn: (funcId: string, args: any[]) => Promise<any>) => void;
-export {};
+export declare const call: (fn: (funcId: string, args: any[]) => any) => void;

package/lib/runtime.js

@@ -1,31 +1,77 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.call = exports.handle = void 0;
+exports.context = context;
 exports.func = func;
-// Implementation
-// In development mode: works at runtime, returns the function as-is.
-// In production mode: transformed by plugin to just the inner function.
-// The plugin appends code to register the function and set requireContext.
+// Context storage - only available on server (Node.js)
+// Lazily initialized to avoid importing async_hooks on client
+function getContextStorage() {
+    if (!globalThis.ZERO_COM_CONTEXT_STORAGE) {
+        try {
+            // Dynamic import to avoid bundling async_hooks for browser
+            const { AsyncLocalStorage } = require('async_hooks');
+            globalThis.ZERO_COM_CONTEXT_STORAGE = new AsyncLocalStorage();
+        }
+        catch (_a) {
+            // Browser environment - context storage not available
+            globalThis.ZERO_COM_CONTEXT_STORAGE = undefined;
+        }
+    }
+    return globalThis.ZERO_COM_CONTEXT_STORAGE;
+}
+// Get the current context - call this inside server functions
+function context() {
+    const storage = getContextStorage();
+    if (!storage) {
+        throw new Error('context() is only available on the server');
+    }
+    const ctx = storage.getStore();
+    if (ctx === undefined) {
+        throw new Error('context() called outside of a server function');
+    }
+    return ctx;
+}
+// Default server-side implementation: call directly from registry
+// This enables server functions to call other server functions without transport
+if (typeof globalThis.ZERO_COM_CLIENT_CALL === 'undefined') {
+    globalThis.ZERO_COM_CLIENT_CALL = (funcId, args) => {
+        var _a;
+        const storage = getContextStorage();
+        if (!storage) {
+            throw new Error('Server function called on client without transport configured. Call call() first.');
+        }
+        const ctx = storage.getStore();
+        if (ctx === undefined) {
+            throw new Error('Server function called outside of request context');
+        }
+        const fn = (_a = globalThis.ZERO_COM_SERVER_REGISTRY) === null || _a === void 0 ? void 0 : _a[funcId];
+        if (!fn)
+            throw new Error(`Function not found: ${funcId}`);
+        return fn(...args);
+    };
+}
+// func() just returns the function as-is
+// In production mode: transformed by plugin to just the inner function
 function func(fn) {
     return fn;
 }
-// In development mode: works at runtime, looks up function and calls it.
-// In production mode: transformed by plugin to inline code.
+// handle() stores context in AsyncLocalStorage and calls the function
+// In production mode: transformed by plugin to inline code
 const handle = (funcId, ctx, args) => {
-    const fn = globalThis.ZERO_COM_SERVER_REGISTRY[funcId];
+    var _a;
+    const fn = (_a = globalThis.ZERO_COM_SERVER_REGISTRY) === null || _a === void 0 ? void 0 : _a[funcId];
     if (!fn) {
         throw new Error(`Function not found in registry: ${funcId}`);
     }
-    if (fn.requireContext) {
-        return fn(ctx, ...args);
-    }
-    else {
-        return fn(...args);
+    const storage = getContextStorage();
+    if (!storage) {
+        throw new Error('handle() is only available on the server');
     }
+    return storage.run(ctx, () => fn(...args));
 };
 exports.handle = handle;
-// In development mode: works at runtime, sets the client call handler.
-// In production mode: transformed by plugin to assignment.
+// Client calls this to set up transport (overrides default server-side behavior)
+// In production mode: transformed by plugin to assignment
 const call = (fn) => {
     globalThis.ZERO_COM_CLIENT_CALL = fn;
 };

package/lib/turbopack-loader.d.ts

@@ -0,0 +1,6 @@
+import type { LoaderContext } from 'webpack';
+export interface TurbopackLoaderOptions {
+    development?: boolean;
+    rootDir?: string;
+}
+export default function turbopackLoader(this: LoaderContext<TurbopackLoaderOptions>, source: string): void;

package/lib/turbopack-loader.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = turbopackLoader;
+const path_1 = __importDefault(require("path"));
+const common_1 = require("./common");
+// Module-level cache: registry is built once and reused across invocations
+let cachedRegistry = null;
+let cachedRootDir = null;
+function turbopackLoader(source) {
+    var _a;
+    const options = this.getOptions();
+    const filePath = this.resourcePath;
+    const rootDir = options.rootDir || this.rootContext || process.cwd();
+    const development = (_a = options.development) !== null && _a !== void 0 ? _a : true;
+    // Lazily build and cache the registry on first invocation or if rootDir changes
+    if (!cachedRegistry || cachedRootDir !== rootDir) {
+        cachedRegistry = new Map();
+        cachedRootDir = rootDir;
+        (0, common_1.buildRegistry)(rootDir, cachedRegistry);
+        console.log(`[TurbopackLoader] Found ${cachedRegistry.size} files with server functions`);
+    }
+    const result = (0, common_1.transformSourceFile)(filePath, source, cachedRegistry, { development });
+    if (!result.transformed) {
+        this.callback(null, source);
+        return;
+    }
+    console.log(`[TurbopackLoader] Transformed: ${path_1.default.basename(filePath)}`);
+    this.callback(null, result.content, result.map);
+}

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "zero-com",
-  "version": "1.6.5",
+  "version": "1.7.1",
   "main": "index.js",
   "repository": "https://github.com/yosbelms/zero-com",
   "keywords": [
     "webpack",
+    "turbopack",
     "api",
     "node",
     "http",