typed-bridge 2.1.1 → 2.1.2

package/dist/demo/bridge/index.d.ts

@@ -166,6 +166,63 @@ declare const _default: {
         updatedAt: import("zod").ZodDate;
     }, import("zod/v4/core").$strip>>>;
     'order.list': () => Promise<order.Order[]>;
+    'order.resolve': (args: import("zod").infer<import("zod").ZodObject<{
+        id: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strip>>, context: {
+        requestedAt: number;
+        userId: number;
+    }) => Promise<import("zod").infer<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        status: import("zod").ZodLiteral<"found">;
+        order: import("zod").ZodObject<{
+            id: import("zod").ZodNumber;
+            customerName: import("zod").ZodString;
+            orderStatus: import("zod").ZodEnum<{
+                pending: "pending";
+                confirmed: "confirmed";
+                shipped: "shipped";
+                delivered: "delivered";
+                cancelled: "cancelled";
+            }>;
+            total: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strip>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        status: import("zod").ZodLiteral<"not_found">;
+    }, import("zod/v4/core").$strip>], "status">>>;
+    'order.statusFilter': (args: import("zod").infer<import("zod").ZodObject<{
+        status: import("zod").ZodEnum<{
+            pending: "pending";
+            confirmed: "confirmed";
+            shipped: "shipped";
+            delivered: "delivered";
+            cancelled: "cancelled";
+        }>;
+    }, import("zod/v4/core").$strip>>, context: {
+        requestedAt: number;
+        userId: number;
+    }) => Promise<import("zod").infer<import("zod").ZodObject<{
+        orders: import("zod").ZodArray<import("zod").ZodObject<{
+            id: import("zod").ZodNumber;
+            status: import("zod").ZodEnum<{
+                pending: "pending";
+                confirmed: "confirmed";
+                shipped: "shipped";
+                delivered: "delivered";
+                cancelled: "cancelled";
+            }>;
+            total: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>>>;
+    'order.tag': (args: import("zod").infer<import("zod").ZodObject<{
+        orderId: import("zod").ZodNumber;
+        tag: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>;
+    }, import("zod/v4/core").$strip>>, context: {
+        requestedAt: number;
+        userId: number;
+    }) => Promise<import("zod").infer<import("zod").ZodObject<{
+        orderId: import("zod").ZodNumber;
+        tag: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>;
+        appliedAt: import("zod").ZodDate;
+    }, import("zod/v4/core").$strip>>>;
     'order.primitives': (args: import("zod").infer<import("zod").ZodObject<{
         key: import("zod").ZodString;
     }, import("zod/v4/core").$strip>>) => Promise<import("zod").infer<import("zod").ZodObject<{

package/dist/demo/bridge/index.js

@@ -49,5 +49,8 @@ exports.default = {
     'order.fetch': order.fetch,
     'order.update': order.update,
     'order.list': order.list,
+    'order.resolve': order.resolve,
+    'order.statusFilter': order.statusFilter,
+    'order.tag': order.tag,
     'order.primitives': order.primitives
 };

package/dist/demo/bridge/order/index.d.ts

@@ -35,5 +35,8 @@ export declare const create: (args: $z.infer<typeof types.create.args>, context:
 export declare const fetch: (args: $z.infer<typeof types.fetch.args>, context: Context) => Promise<$z.infer<typeof types.fetch.res>>;
 export declare const update: (args: $z.infer<typeof types.update.args>, context: Context) => Promise<$z.infer<typeof types.update.res>>;
 export declare const list: () => Promise<Order[]>;
+export declare const resolve: (args: $z.infer<typeof types.resolve.args>, context: Context) => Promise<$z.infer<typeof types.resolve.res>>;
+export declare const statusFilter: (args: $z.infer<typeof types.statusFilter.args>, context: Context) => Promise<$z.infer<typeof types.statusFilter.res>>;
+export declare const tag: (args: $z.infer<typeof types.tag.args>, context: Context) => Promise<$z.infer<typeof types.tag.res>>;
 export declare const primitives: (args: $z.infer<typeof types.primitives.args>) => Promise<$z.infer<typeof types.primitives.res>>;
 export {};

package/dist/demo/bridge/order/index.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.primitives = exports.list = exports.update = exports.fetch = exports.create = void 0;
+exports.primitives = exports.tag = exports.statusFilter = exports.resolve = exports.list = exports.update = exports.fetch = exports.create = void 0;
 const types = __importStar(require("./types"));
 let nextId = 1;
 const orders = [];
@@ -94,6 +94,43 @@ const list = async () => {
     return orders;
 };
 exports.list = list;
+const resolve = async (args, context) => {
+    args = types.resolve.args.parse(args);
+    const order = orders.find(o => o.id === args.id);
+    if (!order)
+        return { status: 'not_found' };
+    return {
+        status: 'found',
+        order: {
+            id: order.id,
+            customerName: `Customer #${order.customerId}`,
+            orderStatus: order.status,
+            total: order.total
+        }
+    };
+};
+exports.resolve = resolve;
+const statusFilter = async (args, context) => {
+    args = types.statusFilter.args.parse(args);
+    return {
+        orders: orders
+            .filter(o => o.status === args.status)
+            .map(o => ({ id: o.id, status: o.status, total: o.total }))
+    };
+};
+exports.statusFilter = statusFilter;
+const orderTags = new Map();
+const tag = async (args, context) => {
+    args = types.tag.args.parse(args);
+    const order = orders.find(o => o.id === args.orderId);
+    if (!order)
+        throw new Error(`Order with ID ${args.orderId} not found`);
+    const tags = orderTags.get(args.orderId) || [];
+    tags.push(args.tag);
+    orderTags.set(args.orderId, tags);
+    return { orderId: args.orderId, tag: args.tag, appliedAt: new Date() };
+};
+exports.tag = tag;
 const primitives = async (args) => {
     args = types.primitives.args.parse(args);
     return {

package/dist/demo/bridge/order/types.d.ts

@@ -97,6 +97,63 @@ export declare const update: {
         updatedAt: $z.ZodDate;
     }, $z.core.$strip>;
 };
+export declare const resolve: {
+    args: $z.ZodObject<{
+        id: $z.ZodNumber;
+    }, $z.core.$strip>;
+    res: $z.ZodDiscriminatedUnion<[$z.ZodObject<{
+        status: $z.ZodLiteral<"found">;
+        order: $z.ZodObject<{
+            id: $z.ZodNumber;
+            customerName: $z.ZodString;
+            orderStatus: $z.ZodEnum<{
+                pending: "pending";
+                confirmed: "confirmed";
+                shipped: "shipped";
+                delivered: "delivered";
+                cancelled: "cancelled";
+            }>;
+            total: $z.ZodNumber;
+        }, $z.core.$strip>;
+    }, $z.core.$strip>, $z.ZodObject<{
+        status: $z.ZodLiteral<"not_found">;
+    }, $z.core.$strip>], "status">;
+};
+export declare const statusFilter: {
+    args: $z.ZodObject<{
+        status: $z.ZodEnum<{
+            pending: "pending";
+            confirmed: "confirmed";
+            shipped: "shipped";
+            delivered: "delivered";
+            cancelled: "cancelled";
+        }>;
+    }, $z.core.$strip>;
+    res: $z.ZodObject<{
+        orders: $z.ZodArray<$z.ZodObject<{
+            id: $z.ZodNumber;
+            status: $z.ZodEnum<{
+                pending: "pending";
+                confirmed: "confirmed";
+                shipped: "shipped";
+                delivered: "delivered";
+                cancelled: "cancelled";
+            }>;
+            total: $z.ZodNumber;
+        }, $z.core.$strip>>;
+    }, $z.core.$strip>;
+};
+export declare const tag: {
+    args: $z.ZodObject<{
+        orderId: $z.ZodNumber;
+        tag: $z.ZodUnion<readonly [$z.ZodString, $z.ZodNumber]>;
+    }, $z.core.$strip>;
+    res: $z.ZodObject<{
+        orderId: $z.ZodNumber;
+        tag: $z.ZodUnion<readonly [$z.ZodString, $z.ZodNumber]>;
+        appliedAt: $z.ZodDate;
+    }, $z.core.$strip>;
+};
 export declare const primitives: {
     args: $z.ZodObject<{
         key: $z.ZodString;

package/dist/demo/bridge/order/types.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.primitives = exports.update = exports.fetch = exports.create = void 0;
+exports.primitives = exports.tag = exports.statusFilter = exports.resolve = exports.update = exports.fetch = exports.create = void 0;
 const __1 = require("../../..");
 // --- Reusable schemas ---
 const addressSchema = __1.$z.object({
@@ -70,6 +70,52 @@ exports.update = {
         updatedAt: __1.$z.date()
     })
 };
+// --- resolve: exercises ZodDiscriminatedUnion + ZodLiteral + ZodEnum ---
+const orderStatusEnum = __1.$z.enum(['pending', 'confirmed', 'shipped', 'delivered', 'cancelled']);
+exports.resolve = {
+    args: __1.$z.object({
+        id: __1.$z.number().min(1)
+    }),
+    res: __1.$z.discriminatedUnion('status', [
+        __1.$z.object({
+            status: __1.$z.literal('found'),
+            order: __1.$z.object({
+                id: __1.$z.number(),
+                customerName: __1.$z.string(),
+                orderStatus: orderStatusEnum,
+                total: __1.$z.number()
+            })
+        }),
+        __1.$z.object({
+            status: __1.$z.literal('not_found')
+        })
+    ])
+};
+// --- statusFilter: exercises ZodEnum in args and response ---
+exports.statusFilter = {
+    args: __1.$z.object({
+        status: orderStatusEnum
+    }),
+    res: __1.$z.object({
+        orders: __1.$z.array(__1.$z.object({
+            id: __1.$z.number(),
+            status: orderStatusEnum,
+            total: __1.$z.number()
+        }))
+    })
+};
+// --- tag: exercises ZodUnion ---
+exports.tag = {
+    args: __1.$z.object({
+        orderId: __1.$z.number().min(1),
+        tag: __1.$z.union([__1.$z.string(), __1.$z.number()])
+    }),
+    res: __1.$z.object({
+        orderId: __1.$z.number(),
+        tag: __1.$z.union([__1.$z.string(), __1.$z.number()]),
+        appliedAt: __1.$z.date()
+    })
+};
 // --- primitives: exercises all remaining keyword types ---
 exports.primitives = {
     args: __1.$z.object({

package/dist/scripts/typedBridgeCleaner.js

@@ -59,9 +59,7 @@ export default typedBridge
 `;
 /**
  * Transformer #1:
- * Resolve zod types to plain TypeScript types, and remove zod imports.
- * Handles both Zod 3 (zod.TypeOf<ZodObject<S,UK,CA,Output,Input>>) and
- * Zod 4 (zod.infer<ZodObject<Shape, UK>>) patterns.
+ * Resolve Zod 4 types to plain TypeScript types, and remove zod imports.
  */
 const resolveZodTypesTransformer = context => {
     return sourceFile => {
@@ -74,23 +72,32 @@ const resolveZodTypesTransformer = context => {
             ZodVoid: typescript_1.default.SyntaxKind.VoidKeyword,
             ZodAny: typescript_1.default.SyntaxKind.AnyKeyword,
             ZodUnknown: typescript_1.default.SyntaxKind.UnknownKeyword,
-            ZodNever: typescript_1.default.SyntaxKind.NeverKeyword,
+            ZodNever: typescript_1.default.SyntaxKind.NeverKeyword
         };
         function getZodRef(node) {
             if (typescript_1.default.isTypeReferenceNode(node) &&
                 typescript_1.default.isQualifiedName(node.typeName) &&
                 typescript_1.default.isIdentifier(node.typeName.left) &&
-                (node.typeName.left.text === 'zod' || node.typeName.left.text.startsWith('zod_'))) {
+                (node.typeName.left.text === 'z' ||
+                    node.typeName.left.text === 'zod' ||
+                    node.typeName.left.text.startsWith('zod_'))) {
                 return { name: node.typeName.right.text, typeArgs: node.typeArguments };
             }
             return null;
         }
+        function unwrapReadonlyTuple(node) {
+            if (typescript_1.default.isTupleTypeNode(node))
+                return node;
+            if (typescript_1.default.isTypeOperatorNode(node) && node.operator === typescript_1.default.SyntaxKind.ReadonlyKeyword && typescript_1.default.isTupleTypeNode(node.type))
+                return node.type;
+            return null;
+        }
         function resolveZodType(node) {
             const ref = getZodRef(node);
             if (!ref)
                 return node;
             const { name, typeArgs } = ref;
-            if ((name === 'infer' || name === 'TypeOf') && typeArgs?.length === 1)
+            if (name === 'infer' && typeArgs?.length === 1)
                 return resolveZodType(typeArgs[0]);
             const keyword = zodKeywordMap[name];
             if (keyword !== undefined)
@@ -99,12 +106,8 @@ const resolveZodTypesTransformer = context => {
                 return typescript_1.default.factory.createLiteralTypeNode(typescript_1.default.factory.createNull());
             if (name === 'ZodDate')
                 return typescript_1.default.factory.createTypeReferenceNode('Date');
-            if (name === 'ZodObject' && typeArgs) {
-                if (typeArgs.length >= 4)
-                    return resolveZodType(typeArgs[3]);
-                if (typeArgs.length >= 1 && typescript_1.default.isTypeLiteralNode(typeArgs[0]))
-                    return resolveShape(typeArgs[0]);
-            }
+            if (name === 'ZodObject' && typeArgs && typeArgs.length >= 1 && typescript_1.default.isTypeLiteralNode(typeArgs[0]))
+                return resolveShape(typeArgs[0]);
             if (name === 'ZodArray' && typeArgs && typeArgs.length >= 1)
                 return typescript_1.default.factory.createArrayTypeNode(resolveZodType(typeArgs[0]));
             if (name === 'ZodOptional' && typeArgs && typeArgs.length >= 1)
@@ -119,6 +122,30 @@ const resolveZodTypesTransformer = context => {
                 ]);
             if (name === 'ZodDefault' && typeArgs && typeArgs.length >= 1)
                 return resolveZodType(typeArgs[0]);
+            if (name === 'ZodLiteral' && typeArgs && typeArgs.length >= 1)
+                return typeArgs[0];
+            // v4: ZodEnum<{pending: "pending", confirmed: "confirmed", ...}>
+            if (name === 'ZodEnum' && typeArgs && typeArgs.length >= 1 && typescript_1.default.isTypeLiteralNode(typeArgs[0])) {
+                const types = [];
+                for (const member of typeArgs[0].members) {
+                    if (typescript_1.default.isPropertySignature(member) && member.type)
+                        types.push(member.type);
+                }
+                if (types.length > 0)
+                    return typescript_1.default.factory.createUnionTypeNode(types);
+            }
+            // v4: ZodDiscriminatedUnion<[ZodObject<...>, ...], "disc">
+            if (name === 'ZodDiscriminatedUnion' && typeArgs && typeArgs.length >= 1) {
+                const tuple = unwrapReadonlyTuple(typeArgs[0]);
+                if (tuple)
+                    return typescript_1.default.factory.createUnionTypeNode(tuple.elements.map(e => resolveZodType(e)));
+            }
+            // v4: ZodUnion<readonly [ZodString, ZodNumber]>
+            if (name === 'ZodUnion' && typeArgs && typeArgs.length >= 1) {
+                const tuple = unwrapReadonlyTuple(typeArgs[0]);
+                if (tuple)
+                    return typescript_1.default.factory.createUnionTypeNode(tuple.elements.map(e => resolveZodType(e)));
+            }
             return node;
         }
         function resolveShape(shape) {
@@ -137,7 +164,7 @@ const resolveZodTypesTransformer = context => {
         function typeVisitor(node) {
             if (typescript_1.default.isTypeNode(node)) {
                 const ref = getZodRef(node);
-                if (ref && (ref.name === 'infer' || ref.name === 'TypeOf'))
+                if (ref)
                     return resolveZodType(node);
             }
             return typescript_1.default.visitEachChild(node, typeVisitor, context);
@@ -205,11 +232,15 @@ const removeDefaultExportTransformer = context => {
  *  3. Writes the final file output.
  */
 function cleanTsFile(src) {
-    let sourceCode = fs_1.default.readFileSync(src, 'utf-8');
+    const sourceCode = fs_1.default.readFileSync(src, 'utf-8');
     // Parse the source
     const sourceFile = typescript_1.default.createSourceFile(path_1.default.basename(src), sourceCode, typescript_1.default.ScriptTarget.Latest, true, typescript_1.default.ScriptKind.TS);
     // Run the transformers
-    const result = typescript_1.default.transform(sourceFile, [resolveZodTypesTransformer, removeSecondParamTransformer, removeDefaultExportTransformer]);
+    const result = typescript_1.default.transform(sourceFile, [
+        resolveZodTypesTransformer,
+        removeSecondParamTransformer,
+        removeDefaultExportTransformer
+    ]);
     // Print final code
     const eslintDisable = `/* eslint-disable */`;
     const printer = typescript_1.default.createPrinter();

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "typed-bridge",
     "description": "Strictly typed server functions for typescript apps",
-    "version": "2.1.1",
+    "version": "2.1.2",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
     "author": "neilveil",

package/test/bridge.ts

@@ -174,6 +174,36 @@ declare const _default: {
         updatedAt: Date;
     }>;
     'order.list': () => Promise<Order[]>;
+    'order.resolve': (args: {
+        id: number;
+    }) => Promise<{
+        status: "found";
+        order: {
+            id: number;
+            customerName: string;
+            orderStatus: "pending" | "confirmed" | "shipped" | "delivered" | "cancelled";
+            total: number;
+        };
+    } | {
+        status: "not_found";
+    }>;
+    'order.statusFilter': (args: {
+        status: "pending" | "confirmed" | "shipped" | "delivered" | "cancelled";
+    }) => Promise<{
+        orders: {
+            id: number;
+            status: "pending" | "confirmed" | "shipped" | "delivered" | "cancelled";
+            total: number;
+        }[];
+    }>;
+    'order.tag': (args: {
+        orderId: number;
+        tag: string | number;
+    }) => Promise<{
+        orderId: number;
+        tag: string | number;
+        appliedAt: Date;
+    }>;
     'order.primitives': (args: {
         key: string;
     }) => Promise<{