@objectstack/spec 0.3.2 → 0.4.1

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" | "split" | "javascript" | "constant";
     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,11 +65,23 @@ 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" | "split" | "javascript" | "constant" | undefined;
 }>;
 /**
- * ETL Mapping Schema
- * Definition for importing/exporting data defined in `integration-etl.mdx`.
+ * Data Mapping Schema
+ * Defines a reusable data mapping configuration for ETL operations.
+ *
+ * **NAMING CONVENTION:**
+ * Mapping names are machine identifiers and must be lowercase snake_case.
+ *
+ * @example Good mapping names
+ * - 'salesforce_to_crm'
+ * - 'csv_import_contacts'
+ * - 'api_sync_orders'
+ *
+ * @example Bad mapping names (will be rejected)
+ * - 'SalesforceToCRM' (PascalCase)
+ * - 'CSV Import' (spaces)
  */
 export declare const MappingSchema: z.ZodObject<{
     /** Identity */
@@ -113,9 +125,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" | "split" | "javascript" | "constant";
         params?: {
             object?: string | undefined;
             value?: any;
@@ -126,8 +138,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 +149,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" | "split" | "javascript" | "constant" | undefined;
     }>, "many">;
     /** Upsert Logic */
     mode: z.ZodDefault<z.ZodEnum<["insert", "update", "upsert"]>>;
@@ -146,22 +158,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 +224,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 +247,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 +263,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 +279,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 +319,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 +358,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" | "split" | "javascript" | "constant";
         params?: {
             object?: string | undefined;
             value?: any;
@@ -361,33 +382,40 @@ export declare const MappingSchema: z.ZodObject<{
             separator?: string | undefined;
         } | undefined;
     }[];
-    errorPolicy: "skip" | "abort" | "retry";
-    batchSize: number;
+    errorPolicy: "abort" | "retry" | "skip";
     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 +424,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 +440,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" | "split" | "javascript" | "constant" | 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 +486,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" | "retry" | "skip" | 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;AAIxB;;;GAGG;AACH,eAAO,MAAM,aAAa,iFAQxB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,kBAAkB;IAC7B,oBAAoB;;IAGpB,mBAAmB;;IAGnB,qBAAqB;;IAGrB,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiBlC,CAAC;AAEH;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,aAAa;IACxB,eAAe;;;IAIf,YAAY;;;IAIZ,sBAAsB;;QArDtB,oBAAoB;;QAGpB,mBAAmB;;QAGnB,qBAAqB;;QAGrB,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA+ClC,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"}

package/dist/data/mapping.zod.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MappingSchema = exports.FieldMappingSchema = exports.TransformType = void 0;
 const zod_1 = require("zod");
+const identifiers_zod_1 = require("../shared/identifiers.zod");
 const query_zod_1 = require("./query.zod");
 /**
  * Transformation Logic
@@ -42,12 +43,24 @@ exports.FieldMappingSchema = zod_1.z.object({
     }).optional()
 });
 /**
- * ETL Mapping Schema
- * Definition for importing/exporting data defined in `integration-etl.mdx`.
+ * Data Mapping Schema
+ * Defines a reusable data mapping configuration for ETL operations.
+ *
+ * **NAMING CONVENTION:**
+ * Mapping names are machine identifiers and must be lowercase snake_case.
+ *
+ * @example Good mapping names
+ * - 'salesforce_to_crm'
+ * - 'csv_import_contacts'
+ * - 'api_sync_orders'
+ *
+ * @example Bad mapping names (will be rejected)
+ * - 'SalesforceToCRM' (PascalCase)
+ * - 'CSV Import' (spaces)
  */
 exports.MappingSchema = zod_1.z.object({
     /** Identity */
-    name: zod_1.z.string().regex(/^[a-z_][a-z0-9_]*$/),
+    name: identifiers_zod_1.SnakeCaseIdentifierSchema.describe('Mapping unique name (lowercase snake_case)'),
     label: zod_1.z.string().optional(),
     /** Scope */
     sourceFormat: zod_1.z.enum(['csv', 'json', 'xml', 'sql']).default('csv'),