@objectstack/spec 0.3.2 → 0.3.3

package/dist/data/hook.zod.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HookContextSchema = exports.HookSchema = exports.HookEvent = void 0;
+const zod_1 = require("zod");
+/**
+ * Hook Lifecycle Events
+ * Defines the interception points in the ObjectQL execution pipeline.
+ */
+exports.HookEvent = zod_1.z.enum([
+    // Read Operations
+    'beforeFind', 'afterFind',
+    'beforeFindOne', 'afterFindOne',
+    'beforeCount', 'afterCount',
+    'beforeAggregate', 'afterAggregate',
+    // Write Operations
+    'beforeInsert', 'afterInsert',
+    'beforeUpdate', 'afterUpdate',
+    'beforeDelete', 'afterDelete',
+    // Bulk Operations (Query-based)
+    'beforeUpdateMany', 'afterUpdateMany',
+    'beforeDeleteMany', 'afterDeleteMany',
+]);
+/**
+ * Hook Definition Schema
+ *
+ * Hooks serve as the "Logic Layer" in ObjectStack, allowing developers to
+ * inject custom code during the data access lifecycle.
+ *
+ * Use cases:
+ * - Data Enrichment (Default values, Calculated fields)
+ * - Validation (Complex business rules)
+ * - Side Effects (Sending emails, Syncing to external systems)
+ * - Security (Filtering data based on context)
+ */
+exports.HookSchema = zod_1.z.object({
+    /**
+     * Unique identifier for the hook
+     * Required for debugging and overriding.
+     */
+    name: zod_1.z.string().regex(/^[a-z_][a-z0-9_]*$/).describe('Hook unique name (snake_case)'),
+    /**
+     * Human readable label
+     */
+    label: zod_1.z.string().optional().describe('Description of what this hook does'),
+    /**
+     * Target Object(s)
+     * can be:
+     * - Single object: "account"
+     * - List of objects: ["account", "contact"]
+     * - Wildcard: "*" (All objects)
+     */
+    object: zod_1.z.union([zod_1.z.string(), zod_1.z.array(zod_1.z.string())]).describe('Target object(s)'),
+    /**
+     * Events to subscribe to
+     * Combinations of timing (before/after) and action (find/insert/update/delete/etc)
+     */
+    events: zod_1.z.array(exports.HookEvent).describe('Lifecycle events'),
+    /**
+     * Handler Logic
+     * Reference to a registered function in the plugin system OR a direct function (runtime only).
+     */
+    handler: zod_1.z.union([zod_1.z.string(), zod_1.z.any()]).optional().describe('Function handler name or direct function'),
+    /**
+     * Execution Order
+     * Lower numbers run first.
+     * - System Hooks: 0-99
+     * - App Hooks: 100-999
+     * - User Hooks: 1000+
+     */
+    priority: zod_1.z.number().default(100).describe('Execution priority'),
+    /**
+     * Async / Background Execution
+     * If true, the hook runs in the background and does not block the transaction.
+     * Only applicable for 'after*' events.
+     * Default: false (Blocking)
+     */
+    async: zod_1.z.boolean().default(false).describe('Run specifically as fire-and-forget'),
+    /**
+     * Error Policy
+     * What to do if the hook throws an exception?
+     * - abort: Rollback transaction (if blocking)
+     * - log: Log error and continue
+     */
+    onError: zod_1.z.enum(['abort', 'log']).default('abort').describe('Error handling strategy'),
+});
+/**
+ * Hook Runtime Context
+ * Defines what is available to the hook handler during execution.
+ *
+ * Best Practices:
+ * - **Immutability**: `object`, `event`, `id` are immutable.
+ * - **Mutability**: `input` and `result` are mutable to allow transformation.
+ * - **Encapsulation**: `session` isolates auth info; `transaction` ensures atomicity.
+ */
+exports.HookContextSchema = zod_1.z.object({
+    /** Tracing ID */
+    id: zod_1.z.string().optional().describe('Unique execution ID for tracing'),
+    /** Target Object Name */
+    object: zod_1.z.string(),
+    /** Current Lifecycle Event */
+    event: exports.HookEvent,
+    /**
+     * Input Parameters (Mutable)
+     * Modify this to change the behavior of the operation.
+     *
+     * - find: { query: QueryAST, options: DriverOptions }
+     * - insert: { doc: Record, options: DriverOptions }
+     * - update: { id: ID, doc: Record, options: DriverOptions }
+     * - delete: { id: ID, options: DriverOptions }
+     * - updateMany: { query: QueryAST, doc: Record, options: DriverOptions }
+     * - deleteMany: { query: QueryAST, options: DriverOptions }
+     */
+    input: zod_1.z.record(zod_1.z.any()).describe('Mutable input parameters'),
+    /**
+     * Operation Result (Mutable)
+     * Available in 'after*' events. Modify this to transform the output.
+     */
+    result: zod_1.z.any().optional().describe('Operation result (After hooks only)'),
+    /**
+     * Data Snapshot
+     * The state of the record BEFORE the operation (for update/delete).
+     */
+    previous: zod_1.z.record(zod_1.z.any()).optional().describe('Record state before operation'),
+    /**
+     * Execution Session
+     * Contains authentication and tenancy information.
+     */
+    session: zod_1.z.object({
+        userId: zod_1.z.string().optional(),
+        tenantId: zod_1.z.string().optional(),
+        roles: zod_1.z.array(zod_1.z.string()).optional(),
+        accessToken: zod_1.z.string().optional(),
+    }).optional().describe('Current session context'),
+    /**
+     * Transaction Handle
+     * If the operation is part of a transaction, use this handle for side-effects.
+     */
+    transaction: zod_1.z.any().optional().describe('Database transaction handle'),
+    /**
+     * Engine Access
+     * Reference to the ObjectQL engine for performing side effects.
+     */
+    ql: zod_1.z.any().describe('ObjectQL Engine Reference'),
+});

package/dist/data/index.d.ts

@@ -1,21 +1,8 @@
-/**
- * Data Protocol Exports
- *
- * Core Business Logic & Data Modeling
- * - Object, Field, Validation
- * - Query (AST), Mapping (ETL)
- * - Permission, Sharing, Flow
- */
-export * from './field.zod';
+export * from './query.zod';
+export * from './filter.zod';
 export * from './object.zod';
+export * from './field.zod';
 export * from './validation.zod';
-export * from './permission.zod';
-export * from './sharing.zod';
-export * from './workflow.zod';
-export * from './flow.zod';
+export * from './hook.zod';
 export * from './dataset.zod';
-export * from './query.zod';
-export * from './filter.zod';
-export * from './mapping.zod';
-export * from './trigger.zod';
 //# sourceMappingURL=index.d.ts.map

package/dist/data/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/data/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/data/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,kBAAkB,CAAC;AACjC,cAAc,YAAY,CAAC;AAE3B,cAAc,eAAe,CAAC"}

package/dist/data/index.js

@@ -1,12 +1,4 @@
 "use strict";
-/**
- * Data Protocol Exports
- *
- * Core Business Logic & Data Modeling
- * - Object, Field, Validation
- * - Query (AST), Mapping (ETL)
- * - Permission, Sharing, Flow
- */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -22,15 +14,10 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./field.zod"), exports);
+__exportStar(require("./query.zod"), exports);
+__exportStar(require("./filter.zod"), exports);
 __exportStar(require("./object.zod"), exports);
+__exportStar(require("./field.zod"), exports);
 __exportStar(require("./validation.zod"), exports);
-__exportStar(require("./permission.zod"), exports);
-__exportStar(require("./sharing.zod"), exports);
-__exportStar(require("./workflow.zod"), exports);
-__exportStar(require("./flow.zod"), exports);
+__exportStar(require("./hook.zod"), exports);
 __exportStar(require("./dataset.zod"), exports);
-__exportStar(require("./query.zod"), exports);
-__exportStar(require("./filter.zod"), exports);
-__exportStar(require("./mapping.zod"), exports);
-__exportStar(require("./trigger.zod"), exports);

package/dist/data/mapping.zod.d.ts

@@ -41,9 +41,9 @@ export declare const FieldMappingSchema: z.ZodObject<{
         separator?: string | undefined;
     }>>;
 }, "strip", z.ZodTypeAny, {
-    source: string | string[];
     target: string | string[];
-    transform: "lookup" | "join" | "map" | "none" | "javascript" | "constant" | "split";
+    source: string | string[];
+    transform: "join" | "map" | "lookup" | "none" | "javascript" | "constant" | "split";
     params?: {
         object?: string | undefined;
         value?: any;
@@ -54,8 +54,8 @@ export declare const FieldMappingSchema: z.ZodObject<{
         separator?: string | undefined;
     } | undefined;
 }, {
-    source: string | string[];
     target: string | string[];
+    source: string | string[];
     params?: {
         object?: string | undefined;
         value?: any;
@@ -65,7 +65,7 @@ export declare const FieldMappingSchema: z.ZodObject<{
         valueMap?: Record<string, any> | undefined;
         separator?: string | undefined;
     } | undefined;
-    transform?: "lookup" | "join" | "map" | "none" | "javascript" | "constant" | "split" | undefined;
+    transform?: "join" | "map" | "lookup" | "none" | "javascript" | "constant" | "split" | undefined;
 }>;
 /**
  * ETL Mapping Schema
@@ -113,9 +113,9 @@ export declare const MappingSchema: z.ZodObject<{
             separator?: string | undefined;
         }>>;
     }, "strip", z.ZodTypeAny, {
-        source: string | string[];
         target: string | string[];
-        transform: "lookup" | "join" | "map" | "none" | "javascript" | "constant" | "split";
+        source: string | string[];
+        transform: "join" | "map" | "lookup" | "none" | "javascript" | "constant" | "split";
         params?: {
             object?: string | undefined;
             value?: any;
@@ -126,8 +126,8 @@ export declare const MappingSchema: z.ZodObject<{
             separator?: string | undefined;
         } | undefined;
     }, {
-        source: string | string[];
         target: string | string[];
+        source: string | string[];
         params?: {
             object?: string | undefined;
             value?: any;
@@ -137,7 +137,7 @@ export declare const MappingSchema: z.ZodObject<{
             valueMap?: Record<string, any> | undefined;
             separator?: string | undefined;
         } | undefined;
-        transform?: "lookup" | "join" | "map" | "none" | "javascript" | "constant" | "split" | undefined;
+        transform?: "join" | "map" | "lookup" | "none" | "javascript" | "constant" | "split" | undefined;
     }>, "many">;
     /** Upsert Logic */
     mode: z.ZodDefault<z.ZodEnum<["insert", "update", "upsert"]>>;
@@ -146,22 +146,42 @@ export declare const MappingSchema: z.ZodObject<{
     extractQuery: z.ZodOptional<z.ZodObject<{
         object: z.ZodString;
         fields: z.ZodOptional<z.ZodArray<z.ZodType<any, z.ZodTypeDef, any>, "many">>;
+        where: z.ZodOptional<z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>>;
+        orderBy: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            order: z.ZodDefault<z.ZodEnum<["asc", "desc"]>>;
+        }, "strip", z.ZodTypeAny, {
+            field: string;
+            order: "asc" | "desc";
+        }, {
+            field: string;
+            order?: "asc" | "desc" | undefined;
+        }>, "many">>;
+        limit: z.ZodOptional<z.ZodNumber>;
+        offset: z.ZodOptional<z.ZodNumber>;
+        cursor: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        joins: z.ZodOptional<z.ZodArray<z.ZodType<any, z.ZodTypeDef, any>, "many">>;
         aggregations: z.ZodOptional<z.ZodArray<z.ZodObject<{
             function: z.ZodEnum<["count", "sum", "avg", "min", "max", "count_distinct", "array_agg", "string_agg"]>;
             field: z.ZodOptional<z.ZodString>;
             alias: z.ZodString;
             distinct: z.ZodOptional<z.ZodBoolean>;
+            filter: z.ZodOptional<z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>>;
         }, "strip", z.ZodTypeAny, {
-            function: "min" | "max" | "count" | "sum" | "avg" | "count_distinct" | "array_agg" | "string_agg";
+            function: "count" | "sum" | "avg" | "min" | "max" | "count_distinct" | "array_agg" | "string_agg";
             alias: string;
+            filter?: import("./filter.zod").FilterCondition | undefined;
             field?: string | undefined;
             distinct?: boolean | undefined;
         }, {
-            function: "min" | "max" | "count" | "sum" | "avg" | "count_distinct" | "array_agg" | "string_agg";
+            function: "count" | "sum" | "avg" | "min" | "max" | "count_distinct" | "array_agg" | "string_agg";
             alias: string;
+            filter?: import("./filter.zod").FilterCondition | undefined;
             field?: string | undefined;
             distinct?: boolean | undefined;
         }>, "many">>;
+        groupBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        having: z.ZodOptional<z.ZodType<import("./filter.zod").FilterCondition, z.ZodTypeDef, import("./filter.zod").FilterCondition>>;
         windowFunctions: z.ZodOptional<z.ZodArray<z.ZodObject<{
             function: z.ZodEnum<["row_number", "rank", "dense_rank", "percent_rank", "lag", "lead", "first_value", "last_value", "sum", "avg", "count", "min", "max"]>;
             field: z.ZodOptional<z.ZodString>;
@@ -192,22 +212,22 @@ export declare const MappingSchema: z.ZodObject<{
                     end?: string | undefined;
                 }>>;
             }, "strip", z.ZodTypeAny, {
-                partitionBy?: string[] | undefined;
                 orderBy?: {
                     field: string;
                     order: "asc" | "desc";
                 }[] | undefined;
+                partitionBy?: string[] | undefined;
                 frame?: {
                     type?: "rows" | "range" | undefined;
                     start?: string | undefined;
                     end?: string | undefined;
                 } | undefined;
             }, {
-                partitionBy?: string[] | undefined;
                 orderBy?: {
                     field: string;
                     order?: "asc" | "desc" | undefined;
                 }[] | undefined;
+                partitionBy?: string[] | undefined;
                 frame?: {
                     type?: "rows" | "range" | undefined;
                     start?: string | undefined;
@@ -215,14 +235,14 @@ export declare const MappingSchema: z.ZodObject<{
                 } | undefined;
             }>;
         }, "strip", z.ZodTypeAny, {
-            function: "min" | "max" | "count" | "sum" | "avg" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            function: "count" | "sum" | "avg" | "min" | "max" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
             alias: string;
             over: {
-                partitionBy?: string[] | undefined;
                 orderBy?: {
                     field: string;
                     order: "asc" | "desc";
                 }[] | undefined;
+                partitionBy?: string[] | undefined;
                 frame?: {
                     type?: "rows" | "range" | undefined;
                     start?: string | undefined;
@@ -231,14 +251,14 @@ export declare const MappingSchema: z.ZodObject<{
             };
             field?: string | undefined;
         }, {
-            function: "min" | "max" | "count" | "sum" | "avg" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            function: "count" | "sum" | "avg" | "min" | "max" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
             alias: string;
             over: {
-                partitionBy?: string[] | undefined;
                 orderBy?: {
                     field: string;
                     order?: "asc" | "desc" | undefined;
                 }[] | undefined;
+                partitionBy?: string[] | undefined;
                 frame?: {
                     type?: "rows" | "range" | undefined;
                     start?: string | undefined;
@@ -247,46 +267,38 @@ export declare const MappingSchema: z.ZodObject<{
             };
             field?: string | undefined;
         }>, "many">>;
-        filters: z.ZodOptional<z.ZodType<any, z.ZodTypeDef, any>>;
-        joins: z.ZodOptional<z.ZodArray<z.ZodType<any, z.ZodTypeDef, any>, "many">>;
-        groupBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        having: z.ZodOptional<z.ZodType<any, z.ZodTypeDef, any>>;
-        sort: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            field: z.ZodString;
-            order: z.ZodDefault<z.ZodEnum<["asc", "desc"]>>;
-        }, "strip", z.ZodTypeAny, {
-            field: string;
-            order: "asc" | "desc";
-        }, {
-            field: string;
-            order?: "asc" | "desc" | undefined;
-        }>, "many">>;
-        top: z.ZodOptional<z.ZodNumber>;
-        skip: z.ZodOptional<z.ZodNumber>;
         distinct: z.ZodOptional<z.ZodBoolean>;
     }, "strip", z.ZodTypeAny, {
         object: string;
-        sort?: {
+        where?: import("./filter.zod").FilterCondition | undefined;
+        distinct?: boolean | undefined;
+        fields?: any[] | undefined;
+        orderBy?: {
             field: string;
             order: "asc" | "desc";
         }[] | undefined;
-        fields?: any[] | undefined;
-        distinct?: boolean | undefined;
+        limit?: number | undefined;
+        offset?: number | undefined;
+        cursor?: Record<string, any> | undefined;
+        joins?: any[] | undefined;
         aggregations?: {
-            function: "min" | "max" | "count" | "sum" | "avg" | "count_distinct" | "array_agg" | "string_agg";
+            function: "count" | "sum" | "avg" | "min" | "max" | "count_distinct" | "array_agg" | "string_agg";
             alias: string;
+            filter?: import("./filter.zod").FilterCondition | undefined;
             field?: string | undefined;
             distinct?: boolean | undefined;
         }[] | undefined;
+        groupBy?: string[] | undefined;
+        having?: import("./filter.zod").FilterCondition | undefined;
         windowFunctions?: {
-            function: "min" | "max" | "count" | "sum" | "avg" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            function: "count" | "sum" | "avg" | "min" | "max" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
             alias: string;
             over: {
-                partitionBy?: string[] | undefined;
                 orderBy?: {
                     field: string;
                     order: "asc" | "desc";
                 }[] | undefined;
+                partitionBy?: string[] | undefined;
                 frame?: {
                     type?: "rows" | "range" | undefined;
                     start?: string | undefined;
@@ -295,35 +307,37 @@ export declare const MappingSchema: z.ZodObject<{
             };
             field?: string | undefined;
         }[] | undefined;
-        filters?: any;
-        joins?: any[] | undefined;
-        groupBy?: string[] | undefined;
-        having?: any;
-        top?: number | undefined;
-        skip?: number | undefined;
     }, {
         object: string;
-        sort?: {
+        where?: import("./filter.zod").FilterCondition | undefined;
+        distinct?: boolean | undefined;
+        fields?: any[] | undefined;
+        orderBy?: {
             field: string;
             order?: "asc" | "desc" | undefined;
         }[] | undefined;
-        fields?: any[] | undefined;
-        distinct?: boolean | undefined;
+        limit?: number | undefined;
+        offset?: number | undefined;
+        cursor?: Record<string, any> | undefined;
+        joins?: any[] | undefined;
         aggregations?: {
-            function: "min" | "max" | "count" | "sum" | "avg" | "count_distinct" | "array_agg" | "string_agg";
+            function: "count" | "sum" | "avg" | "min" | "max" | "count_distinct" | "array_agg" | "string_agg";
             alias: string;
+            filter?: import("./filter.zod").FilterCondition | undefined;
             field?: string | undefined;
             distinct?: boolean | undefined;
         }[] | undefined;
+        groupBy?: string[] | undefined;
+        having?: import("./filter.zod").FilterCondition | undefined;
         windowFunctions?: {
-            function: "min" | "max" | "count" | "sum" | "avg" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            function: "count" | "sum" | "avg" | "min" | "max" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
             alias: string;
             over: {
-                partitionBy?: string[] | undefined;
                 orderBy?: {
                     field: string;
                     order?: "asc" | "desc" | undefined;
                 }[] | undefined;
+                partitionBy?: string[] | undefined;
                 frame?: {
                     type?: "rows" | "range" | undefined;
                     start?: string | undefined;
@@ -332,25 +346,20 @@ export declare const MappingSchema: z.ZodObject<{
             };
             field?: string | undefined;
         }[] | undefined;
-        filters?: any;
-        joins?: any[] | undefined;
-        groupBy?: string[] | undefined;
-        having?: any;
-        top?: number | undefined;
-        skip?: number | undefined;
     }>>;
     /** Error Handling */
     errorPolicy: z.ZodDefault<z.ZodEnum<["skip", "abort", "retry"]>>;
     batchSize: z.ZodDefault<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
     name: string;
-    mode: "update" | "upsert" | "insert";
-    sourceFormat: "json" | "csv" | "xml" | "sql";
+    mode: "insert" | "update" | "upsert";
+    batchSize: number;
     targetObject: string;
+    sourceFormat: "json" | "csv" | "xml" | "sql";
     fieldMapping: {
-        source: string | string[];
         target: string | string[];
-        transform: "lookup" | "join" | "map" | "none" | "javascript" | "constant" | "split";
+        source: string | string[];
+        transform: "join" | "map" | "lookup" | "none" | "javascript" | "constant" | "split";
         params?: {
             object?: string | undefined;
             value?: any;
@@ -361,33 +370,40 @@ export declare const MappingSchema: z.ZodObject<{
             separator?: string | undefined;
         } | undefined;
     }[];
-    errorPolicy: "skip" | "abort" | "retry";
-    batchSize: number;
+    errorPolicy: "abort" | "skip" | "retry";
     label?: string | undefined;
     upsertKey?: string[] | undefined;
     extractQuery?: {
         object: string;
-        sort?: {
+        where?: import("./filter.zod").FilterCondition | undefined;
+        distinct?: boolean | undefined;
+        fields?: any[] | undefined;
+        orderBy?: {
             field: string;
             order: "asc" | "desc";
         }[] | undefined;
-        fields?: any[] | undefined;
-        distinct?: boolean | undefined;
+        limit?: number | undefined;
+        offset?: number | undefined;
+        cursor?: Record<string, any> | undefined;
+        joins?: any[] | undefined;
         aggregations?: {
-            function: "min" | "max" | "count" | "sum" | "avg" | "count_distinct" | "array_agg" | "string_agg";
+            function: "count" | "sum" | "avg" | "min" | "max" | "count_distinct" | "array_agg" | "string_agg";
             alias: string;
+            filter?: import("./filter.zod").FilterCondition | undefined;
             field?: string | undefined;
             distinct?: boolean | undefined;
         }[] | undefined;
+        groupBy?: string[] | undefined;
+        having?: import("./filter.zod").FilterCondition | undefined;
         windowFunctions?: {
-            function: "min" | "max" | "count" | "sum" | "avg" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            function: "count" | "sum" | "avg" | "min" | "max" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
             alias: string;
             over: {
-                partitionBy?: string[] | undefined;
                 orderBy?: {
                     field: string;
                     order: "asc" | "desc";
                 }[] | undefined;
+                partitionBy?: string[] | undefined;
                 frame?: {
                     type?: "rows" | "range" | undefined;
                     start?: string | undefined;
@@ -396,19 +412,13 @@ export declare const MappingSchema: z.ZodObject<{
             };
             field?: string | undefined;
         }[] | undefined;
-        filters?: any;
-        joins?: any[] | undefined;
-        groupBy?: string[] | undefined;
-        having?: any;
-        top?: number | undefined;
-        skip?: number | undefined;
     } | undefined;
 }, {
     name: string;
     targetObject: string;
     fieldMapping: {
-        source: string | string[];
         target: string | string[];
+        source: string | string[];
         params?: {
             object?: string | undefined;
             value?: any;
@@ -418,35 +428,44 @@ export declare const MappingSchema: z.ZodObject<{
             valueMap?: Record<string, any> | undefined;
             separator?: string | undefined;
         } | undefined;
-        transform?: "lookup" | "join" | "map" | "none" | "javascript" | "constant" | "split" | undefined;
+        transform?: "join" | "map" | "lookup" | "none" | "javascript" | "constant" | "split" | undefined;
     }[];
     label?: string | undefined;
-    mode?: "update" | "upsert" | "insert" | undefined;
+    mode?: "insert" | "update" | "upsert" | undefined;
+    batchSize?: number | undefined;
     sourceFormat?: "json" | "csv" | "xml" | "sql" | undefined;
     upsertKey?: string[] | undefined;
     extractQuery?: {
         object: string;
-        sort?: {
+        where?: import("./filter.zod").FilterCondition | undefined;
+        distinct?: boolean | undefined;
+        fields?: any[] | undefined;
+        orderBy?: {
             field: string;
             order?: "asc" | "desc" | undefined;
         }[] | undefined;
-        fields?: any[] | undefined;
-        distinct?: boolean | undefined;
+        limit?: number | undefined;
+        offset?: number | undefined;
+        cursor?: Record<string, any> | undefined;
+        joins?: any[] | undefined;
         aggregations?: {
-            function: "min" | "max" | "count" | "sum" | "avg" | "count_distinct" | "array_agg" | "string_agg";
+            function: "count" | "sum" | "avg" | "min" | "max" | "count_distinct" | "array_agg" | "string_agg";
             alias: string;
+            filter?: import("./filter.zod").FilterCondition | undefined;
             field?: string | undefined;
             distinct?: boolean | undefined;
         }[] | undefined;
+        groupBy?: string[] | undefined;
+        having?: import("./filter.zod").FilterCondition | undefined;
         windowFunctions?: {
-            function: "min" | "max" | "count" | "sum" | "avg" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
+            function: "count" | "sum" | "avg" | "min" | "max" | "row_number" | "rank" | "dense_rank" | "percent_rank" | "lag" | "lead" | "first_value" | "last_value";
             alias: string;
             over: {
-                partitionBy?: string[] | undefined;
                 orderBy?: {
                     field: string;
                     order?: "asc" | "desc" | undefined;
                 }[] | undefined;
+                partitionBy?: string[] | undefined;
                 frame?: {
                     type?: "rows" | "range" | undefined;
                     start?: string | undefined;
@@ -455,15 +474,8 @@ export declare const MappingSchema: z.ZodObject<{
             };
             field?: string | undefined;
         }[] | undefined;
-        filters?: any;
-        joins?: any[] | undefined;
-        groupBy?: string[] | undefined;
-        having?: any;
-        top?: number | undefined;
-        skip?: number | undefined;
     } | undefined;
-    errorPolicy?: "skip" | "abort" | "retry" | undefined;
-    batchSize?: number | undefined;
+    errorPolicy?: "abort" | "skip" | "retry" | undefined;
 }>;
 export type Mapping = z.infer<typeof MappingSchema>;
 export type FieldMapping = z.infer<typeof FieldMappingSchema>;

package/dist/data/mapping.zod.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mapping.zod.d.ts","sourceRoot":"","sources":["../../src/data/mapping.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;GAGG;AACH,eAAO,MAAM,aAAa,iFAQxB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,kBAAkB;IAC7B,oBAAoB;;IAGpB,mBAAmB;;IAGnB,qBAAqB;;IAGrB,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiBlC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,aAAa;IACxB,eAAe;;;IAIf,YAAY;;;IAIZ,sBAAsB;;QAzCtB,oBAAoB;;QAGpB,mBAAmB;;QAGnB,qBAAqB;;QAGrB,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAmClC,mBAAmB;;;IAInB,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAGjC,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGrB,CAAC;AAEH,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AACpD,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}
+{"version":3,"file":"mapping.zod.d.ts","sourceRoot":"","sources":["../../src/data/mapping.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;GAGG;AACH,eAAO,MAAM,aAAa,iFAQxB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,kBAAkB;IAC7B,oBAAoB;;IAGpB,mBAAmB;;IAGnB,qBAAqB;;IAGrB,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiBlC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,aAAa;IACxB,eAAe;;;IAIf,YAAY;;;IAIZ,sBAAsB;;QAzCtB,oBAAoB;;QAGpB,mBAAmB;;QAGnB,qBAAqB;;QAGrB,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAmClC,mBAAmB;;;IAInB,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAGjC,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGrB,CAAC;AAEH,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AACpD,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}