@middlewr/contracts 0.0.46 → 0.0.47

package/dist/cjs/index.js

@@ -60,6 +60,7 @@ __export(index_exports, {
   PlansOutputSchema: () => PlansOutputSchema,
   QrCodeSettingsSchema: () => QrCodeSettingsSchema,
   RuleGraphNodeSchema: () => RuleGraphNodeSchema,
+  RuleGraphOutputSchema: () => RuleGraphOutputSchema,
   RuleGraphSchema: () => RuleGraphSchema,
   SignInInputSchema: () => SignInInputSchema,
   TagIdParamSchema: () => TagIdParamSchema,
@@ -386,10 +387,15 @@ var RuleGraphNodeSchema = import_zod6.z.discriminatedUnion("type", [
   PasswordNodeSchema,
   EntryNodeSchema
 ]);
-var RuleGraphSchema = import_zod6.z.object({
+var BaseRuleGraphSchema = import_zod6.z.object({
   entry: import_zod6.z.string(),
   nodes: import_zod6.z.record(import_zod6.z.string(), RuleGraphNodeSchema)
-}).refine((data) => data.nodes[data.entry] !== void 0, {
+});
+var RuleGraphOutputSchema = BaseRuleGraphSchema.refine((data) => data.nodes[data.entry] !== void 0, {
+  message: "Entry node must reference an existing node in the graph",
+  path: ["entry"]
+});
+var RuleGraphSchema = BaseRuleGraphSchema.refine((data) => data.nodes[data.entry] !== void 0, {
   message: "Entry node must reference an existing node in the graph",
   path: ["entry"]
 }).refine(
@@ -418,7 +424,7 @@ var LinkTemplateSchema = import_zod7.z.object({
   workspace_id: import_zod7.z.string().uuid(),
   title: import_zod7.z.string(),
   description: import_zod7.z.string().nullable(),
-  rule_graph: RuleGraphSchema.nullable(),
+  rule_graph: RuleGraphOutputSchema.nullable(),
   created_at: import_zod7.z.coerce.date(),
   updated_at: import_zod7.z.coerce.date().nullable()
 });
@@ -511,7 +517,7 @@ var LinkSchema = import_zod9.z.object({
   qr_logo_key: import_zod9.z.string().nullable(),
   logo_url: import_zod9.z.string().nullable(),
   link_type: import_zod9.z.enum(["redirect", "rules"]).default("redirect"),
-  rule_graph: RuleGraphSchema.nullable().optional(),
+  rule_graph: RuleGraphOutputSchema.nullable().optional(),
   tags: import_zod9.z.array(TagSchema)
 });
 var CreateLinkInputSchema = import_zod9.z.object({
@@ -835,6 +841,7 @@ var contract = {
   PlansOutputSchema,
   QrCodeSettingsSchema,
   RuleGraphNodeSchema,
+  RuleGraphOutputSchema,
   RuleGraphSchema,
   SignInInputSchema,
   TagIdParamSchema,

package/dist/cjs/rules.schema.d.ts

@@ -88,6 +88,98 @@ export declare const RuleGraphNodeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     }, z.core.$strip>;
     next: z.ZodNullable<z.ZodString>;
 }, z.core.$strip>], "type">;
+export declare const RuleGraphOutputSchema: z.ZodObject<{
+    entry: z.ZodString;
+    nodes: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"condition">;
+        position: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$strip>;
+        field: z.ZodString;
+        operator: z.ZodEnum<{
+            eq: "eq";
+            neq: "neq";
+            in: "in";
+            not_in: "not_in";
+            contains: "contains";
+            not_contains: "not_contains";
+            gt: "gt";
+            lt: "lt";
+            gte: "gte";
+            lte: "lte";
+            regex: "regex";
+        }>;
+        value: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodNumber]>;
+        outputs: z.ZodObject<{
+            true: z.ZodNullable<z.ZodString>;
+            false: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"split">;
+        position: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$strip>;
+        variants: z.ZodArray<z.ZodObject<{
+            weight: z.ZodNumber;
+            target: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"destination">;
+        position: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$strip>;
+        url: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"transform">;
+        position: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$strip>;
+        transforms: z.ZodObject<{
+            query_params: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                value: z.ZodString;
+                mode: z.ZodEnum<{
+                    set: "set";
+                    append: "append";
+                }>;
+            }, z.core.$strip>>>;
+            redirect_status: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<301>, z.ZodLiteral<302>, z.ZodLiteral<307>, z.ZodLiteral<308>]>>;
+            response_headers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                value: z.ZodString;
+                mode: z.ZodEnum<{
+                    set: "set";
+                    append: "append";
+                }>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>;
+        next: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"password">;
+        position: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$strip>;
+        next: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"entry">;
+        position: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$strip>;
+        next: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>], "type">>;
+}, z.core.$strip>;
 export declare const RuleGraphSchema: z.ZodObject<{
     entry: z.ZodString;
     nodes: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{

package/dist/cjs/rules.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rules.schema.d.ts","sourceRoot":"","sources":["../../src/rules.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA+FxB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAO9B,CAAC;AAEH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4BvB,CAAC"}
+{"version":3,"file":"rules.schema.d.ts","sourceRoot":"","sources":["../../src/rules.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA+FxB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAO9B,CAAC;AAOH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAGhC,CAAC;AAEH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuBvB,CAAC"}

package/dist/esm/index.js

@@ -286,10 +286,15 @@ var RuleGraphNodeSchema = z6.discriminatedUnion("type", [
   PasswordNodeSchema,
   EntryNodeSchema
 ]);
-var RuleGraphSchema = z6.object({
+var BaseRuleGraphSchema = z6.object({
   entry: z6.string(),
   nodes: z6.record(z6.string(), RuleGraphNodeSchema)
-}).refine((data) => data.nodes[data.entry] !== void 0, {
+});
+var RuleGraphOutputSchema = BaseRuleGraphSchema.refine((data) => data.nodes[data.entry] !== void 0, {
+  message: "Entry node must reference an existing node in the graph",
+  path: ["entry"]
+});
+var RuleGraphSchema = BaseRuleGraphSchema.refine((data) => data.nodes[data.entry] !== void 0, {
   message: "Entry node must reference an existing node in the graph",
   path: ["entry"]
 }).refine(
@@ -318,7 +323,7 @@ var LinkTemplateSchema = z7.object({
   workspace_id: z7.string().uuid(),
   title: z7.string(),
   description: z7.string().nullable(),
-  rule_graph: RuleGraphSchema.nullable(),
+  rule_graph: RuleGraphOutputSchema.nullable(),
   created_at: z7.coerce.date(),
   updated_at: z7.coerce.date().nullable()
 });
@@ -411,7 +416,7 @@ var LinkSchema = z9.object({
   qr_logo_key: z9.string().nullable(),
   logo_url: z9.string().nullable(),
   link_type: z9.enum(["redirect", "rules"]).default("redirect"),
-  rule_graph: RuleGraphSchema.nullable().optional(),
+  rule_graph: RuleGraphOutputSchema.nullable().optional(),
   tags: z9.array(TagSchema)
 });
 var CreateLinkInputSchema = z9.object({
@@ -734,6 +739,7 @@ export {
   PlansOutputSchema,
   QrCodeSettingsSchema,
   RuleGraphNodeSchema,
+  RuleGraphOutputSchema,
   RuleGraphSchema,
   SignInInputSchema,
   TagIdParamSchema,

package/dist/esm/rules.schema.d.ts

@@ -88,6 +88,98 @@ export declare const RuleGraphNodeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     }, z.core.$strip>;
     next: z.ZodNullable<z.ZodString>;
 }, z.core.$strip>], "type">;
+export declare const RuleGraphOutputSchema: z.ZodObject<{
+    entry: z.ZodString;
+    nodes: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"condition">;
+        position: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$strip>;
+        field: z.ZodString;
+        operator: z.ZodEnum<{
+            eq: "eq";
+            neq: "neq";
+            in: "in";
+            not_in: "not_in";
+            contains: "contains";
+            not_contains: "not_contains";
+            gt: "gt";
+            lt: "lt";
+            gte: "gte";
+            lte: "lte";
+            regex: "regex";
+        }>;
+        value: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodNumber]>;
+        outputs: z.ZodObject<{
+            true: z.ZodNullable<z.ZodString>;
+            false: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"split">;
+        position: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$strip>;
+        variants: z.ZodArray<z.ZodObject<{
+            weight: z.ZodNumber;
+            target: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"destination">;
+        position: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$strip>;
+        url: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"transform">;
+        position: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$strip>;
+        transforms: z.ZodObject<{
+            query_params: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                value: z.ZodString;
+                mode: z.ZodEnum<{
+                    set: "set";
+                    append: "append";
+                }>;
+            }, z.core.$strip>>>;
+            redirect_status: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<301>, z.ZodLiteral<302>, z.ZodLiteral<307>, z.ZodLiteral<308>]>>;
+            response_headers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                value: z.ZodString;
+                mode: z.ZodEnum<{
+                    set: "set";
+                    append: "append";
+                }>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>;
+        next: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"password">;
+        position: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$strip>;
+        next: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"entry">;
+        position: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$strip>;
+        next: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>], "type">>;
+}, z.core.$strip>;
 export declare const RuleGraphSchema: z.ZodObject<{
     entry: z.ZodString;
     nodes: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{

package/dist/esm/rules.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rules.schema.d.ts","sourceRoot":"","sources":["../../src/rules.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA+FxB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAO9B,CAAC;AAEH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4BvB,CAAC"}
+{"version":3,"file":"rules.schema.d.ts","sourceRoot":"","sources":["../../src/rules.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA+FxB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAO9B,CAAC;AAOH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAGhC,CAAC;AAEH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuBvB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@middlewr/contracts",
-    "version": "0.0.46",
+    "version": "0.0.47",
     "type": "module",
     "main": "./dist/cjs/index.js",
     "module": "./dist/esm/index.js",

package/src/link-templates.schema.ts

@@ -1,13 +1,13 @@
 import { z } from 'zod';
 
-import { RuleGraphSchema } from './rules.schema';
+import { RuleGraphOutputSchema, RuleGraphSchema } from './rules.schema';
 
 export const LinkTemplateSchema = z.object({
     id: z.string().uuid(),
     workspace_id: z.string().uuid(),
     title: z.string(),
     description: z.string().nullable(),
-    rule_graph: RuleGraphSchema.nullable(),
+    rule_graph: RuleGraphOutputSchema.nullable(),
     created_at: z.coerce.date(),
     updated_at: z.coerce.date().nullable(),
 });

package/src/links.schema.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 
-import { RuleGraphSchema } from './rules.schema';
+import { RuleGraphOutputSchema, RuleGraphSchema } from './rules.schema';
 import { TagSchema } from './tags.schema';
 
 const DotStyleSchema = z.enum(['square', 'dots', 'rounded', 'classy', 'classy-rounded', 'extra-rounded']);
@@ -48,7 +48,7 @@ export const LinkSchema = z.object({
     qr_logo_key: z.string().nullable(),
     logo_url: z.string().nullable(),
     link_type: z.enum(['redirect', 'rules']).default('redirect'),
-    rule_graph: RuleGraphSchema.nullable().optional(),
+    rule_graph: RuleGraphOutputSchema.nullable().optional(),
     tags: z.array(TagSchema),
 });
 

package/src/rules.schema.ts

@@ -102,15 +102,20 @@ export const RuleGraphNodeSchema = z.discriminatedUnion('type', [
     EntryNodeSchema,
 ]);
 
-export const RuleGraphSchema = z
-    .object({
-        entry: z.string(),
-        nodes: z.record(z.string(), RuleGraphNodeSchema),
-    })
-    .refine((data) => data.nodes[data.entry] !== undefined, {
-        message: 'Entry node must reference an existing node in the graph',
-        path: ['entry'],
-    })
+const BaseRuleGraphSchema = z.object({
+    entry: z.string(),
+    nodes: z.record(z.string(), RuleGraphNodeSchema),
+});
+
+export const RuleGraphOutputSchema = BaseRuleGraphSchema.refine((data) => data.nodes[data.entry] !== undefined, {
+    message: 'Entry node must reference an existing node in the graph',
+    path: ['entry'],
+});
+
+export const RuleGraphSchema = BaseRuleGraphSchema.refine((data) => data.nodes[data.entry] !== undefined, {
+    message: 'Entry node must reference an existing node in the graph',
+    path: ['entry'],
+})
     .refine(
         (data) => {
             const entryNode = data.nodes[data.entry];