@objectstack/spec 0.1.1 → 0.1.2

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

@@ -1 +1 @@
-{"version":3,"file":"object.zod.d.ts","sourceRoot":"","sources":["../../src/data/object.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;GAGG;AACH,eAAO,MAAM,kBAAkB;IAC7B,4CAA4C;;IAG5C,oCAAoC;;IAGpC,qCAAqC;;IAGrC,+BAA+B;;IAG/B,iCAAiC;;IAGjC,mCAAmC;;;;;;;;;;;;;;;;EAEnC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;EAItB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,YAAY;IACvB,eAAe;;;;;;IAOf,qBAAqB;;;;IAKrB,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAGxB,cAAc;;;;;;;;;;;;;;IAGd,iBAAiB;;IAGjB,8BAA8B;;QArD9B,4CAA4C;;QAG5C,oCAAoC;;QAGpC,qCAAqC;;QAGrC,+BAA+B;;QAG/B,iCAAiC;;QAGjC,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwCnC,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC"}
+{"version":3,"file":"object.zod.d.ts","sourceRoot":"","sources":["../../src/data/object.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;GAGG;AACH,eAAO,MAAM,kBAAkB;IAC7B,4CAA4C;;IAG5C,oCAAoC;;IAGpC,qCAAqC;;IAGrC;;;;OAIG;;IAeH,+BAA+B;;IAG/B,iCAAiC;;IAGjC,mCAAmC;;;;;;;;;;;;;;;;;;EAEnC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;EAItB,CAAC;AAEH;;GAEG;AACH,QAAA,MAAM,gBAAgB;IACpB,eAAe;;;;;;IAOf;;;OAGG;;;;IAKH,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAGxB,cAAc;;;;;;;;;;;;;;IAGd,iBAAiB;;IAGjB,8BAA8B;;QA3E9B,4CAA4C;;QAG5C,oCAAoC;;QAGpC,qCAAqC;;QAGrC;;;;WAIG;;QAeH,+BAA+B;;QAG/B,iCAAiC;;QAGjC,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2CnC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,YAAY;IA/BvB,eAAe;;;;;;IAOf;;;OAGG;;;;IAKH,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAGxB,cAAc;;;;;;;;;;;;;;IAGd,iBAAiB;;IAGjB,8BAA8B;;QA3E9B,4CAA4C;;QAG5C,oCAAoC;;QAGpC,qCAAqC;;QAGrC;;;;WAIG;;QAeH,+BAA+B;;QAG/B,iCAAiC;;QAGjC,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAiD1B,CAAC,SAAS,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,UAAU,CAAC;CAC9D,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC"}

package/dist/data/object.zod.js

@@ -14,6 +14,24 @@ exports.ObjectCapabilities = zod_1.z.object({
     searchable: zod_1.z.boolean().default(true),
     /** Enable REST/GraphQL API access */
     apiEnabled: zod_1.z.boolean().default(true),
+    /**
+     * API Supported Operations
+     * Explicitly whitelist allowed operations.
+     * If not defined, all standard operations are allowed (if apiEnabled=true).
+     */
+    apiMethods: zod_1.z.array(zod_1.z.enum([
+        'get', 'list',
+        'create', 'update', 'delete',
+        'upsert',
+        'bulkCreate', 'bulkUpdate', 'bulkDelete', 'bulkUpsert',
+        'aggregate', // count, sum, group by
+        'history', // audit trail access
+        'search', // full text search
+        'restore', // undelete from trash
+        'purge', // hard delete
+        'import', // data import
+        'export', // data export
+    ])).optional().describe('Allowed API operations'),
     /** Enable attachments/files */
     files: zod_1.z.boolean().default(false),
     /** Enable discussions/chatter */
@@ -30,18 +48,21 @@ exports.IndexSchema = zod_1.z.object({
     unique: zod_1.z.boolean().optional().describe('Whether the index is unique'),
 });
 /**
- * Object Schema - Enterprise Data Model
+ * Base Object Schema Definition
  */
-exports.ObjectSchema = zod_1.z.object({
+const ObjectSchemaBase = zod_1.z.object({
     /** Identify */
     name: zod_1.z.string().regex(/^[a-z_][a-z0-9_]*$/).describe('Machine name (snake_case)'),
     label: zod_1.z.string().optional().describe('Singular Label (e.g. "Account")'),
     pluralLabel: zod_1.z.string().optional().describe('Plural Label (e.g. "Accounts")'),
     description: zod_1.z.string().optional().describe('Internal description'),
     icon: zod_1.z.string().optional().describe('Lucide icon name'),
-    /** Storage Config */
-    datasource: zod_1.z.string().default('default').describe('Datasource name'),
-    tableName: zod_1.z.string().optional().describe('Physical DB table override'),
+    /**
+     * Storage / Virtualization Config
+     * Defines where the data actually lives.
+     */
+    datasource: zod_1.z.string().default('default').describe('Target Datasource ID (e.g. "postgres", "salesforce"). references sys_datasource.'),
+    tableName: zod_1.z.string().optional().describe('Physical table/collection name in the target datasource'),
     isSystem: zod_1.z.boolean().default(false).describe('Is system object (protected)'),
     /** Fields Definition */
     fields: zod_1.z.record(field_zod_1.FieldSchema).describe('Map of field definitions'),
@@ -52,3 +73,9 @@ exports.ObjectSchema = zod_1.z.object({
     /** Features & Capabilities */
     enable: exports.ObjectCapabilities.optional().describe('Enabled system capabilities'),
 });
+/**
+ * Enhanced ObjectSchema with Factory
+ */
+exports.ObjectSchema = Object.assign(ObjectSchemaBase, {
+    create: (config) => config,
+});

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

@@ -32,6 +32,185 @@ export declare const SortNodeSchema: z.ZodObject<{
     field: string;
     order?: "asc" | "desc" | undefined;
 }>;
+/**
+ * Aggregation Function Enum
+ * Standard aggregation functions.
+ */
+export declare const AggregationFunction: z.ZodEnum<["count", "sum", "avg", "min", "max", "count_distinct", "array_agg", "string_agg"]>;
+/**
+ * Aggregation Node
+ * Represents aggregated field with function.
+ */
+export declare const AggregationNodeSchema: 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>;
+}, "strip", z.ZodTypeAny, {
+    function: "min" | "max" | "count" | "sum" | "avg" | "count_distinct" | "array_agg" | "string_agg";
+    alias: string;
+    field?: string | undefined;
+    distinct?: boolean | undefined;
+}, {
+    function: "min" | "max" | "count" | "sum" | "avg" | "count_distinct" | "array_agg" | "string_agg";
+    alias: string;
+    field?: string | undefined;
+    distinct?: boolean | undefined;
+}>;
+/**
+ * Join Type Enum
+ */
+export declare const JoinType: z.ZodEnum<["inner", "left", "right", "full"]>;
+/**
+ * Join Node
+ * Represents table joins.
+ */
+export declare const JoinNodeSchema: z.ZodType<any>;
+/**
+ * Window Function Enum
+ */
+export declare const WindowFunction: z.ZodEnum<["row_number", "rank", "dense_rank", "percent_rank", "lag", "lead", "first_value", "last_value", "sum", "avg", "count", "min", "max"]>;
+/**
+ * Window Specification
+ * Defines PARTITION BY and ORDER BY for window functions.
+ */
+export declare const WindowSpecSchema: z.ZodObject<{
+    partitionBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    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">>;
+    frame: z.ZodOptional<z.ZodObject<{
+        type: z.ZodOptional<z.ZodEnum<["rows", "range"]>>;
+        start: z.ZodOptional<z.ZodString>;
+        end: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type?: "rows" | "range" | undefined;
+        start?: string | undefined;
+        end?: string | undefined;
+    }, {
+        type?: "rows" | "range" | undefined;
+        start?: string | undefined;
+        end?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    partitionBy?: string[] | undefined;
+    orderBy?: {
+        field: string;
+        order: "asc" | "desc";
+    }[] | undefined;
+    frame?: {
+        type?: "rows" | "range" | undefined;
+        start?: string | undefined;
+        end?: string | undefined;
+    } | undefined;
+}, {
+    partitionBy?: string[] | undefined;
+    orderBy?: {
+        field: string;
+        order?: "asc" | "desc" | undefined;
+    }[] | undefined;
+    frame?: {
+        type?: "rows" | "range" | undefined;
+        start?: string | undefined;
+        end?: string | undefined;
+    } | undefined;
+}>;
+/**
+ * Window Function Node
+ * Represents window function with OVER clause.
+ */
+export declare const WindowFunctionNodeSchema: 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>;
+    alias: z.ZodString;
+    over: z.ZodObject<{
+        partitionBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        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">>;
+        frame: z.ZodOptional<z.ZodObject<{
+            type: z.ZodOptional<z.ZodEnum<["rows", "range"]>>;
+            start: z.ZodOptional<z.ZodString>;
+            end: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            type?: "rows" | "range" | undefined;
+            start?: string | undefined;
+            end?: string | undefined;
+        }, {
+            type?: "rows" | "range" | undefined;
+            start?: string | undefined;
+            end?: string | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        partitionBy?: string[] | undefined;
+        orderBy?: {
+            field: string;
+            order: "asc" | "desc";
+        }[] | undefined;
+        frame?: {
+            type?: "rows" | "range" | undefined;
+            start?: string | undefined;
+            end?: string | undefined;
+        } | undefined;
+    }, {
+        partitionBy?: string[] | undefined;
+        orderBy?: {
+            field: string;
+            order?: "asc" | "desc" | undefined;
+        }[] | undefined;
+        frame?: {
+            type?: "rows" | "range" | undefined;
+            start?: string | undefined;
+            end?: string | undefined;
+        } | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    function: "min" | "max" | "count" | "sum" | "avg" | "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;
+        frame?: {
+            type?: "rows" | "range" | undefined;
+            start?: string | undefined;
+            end?: string | undefined;
+        } | undefined;
+    };
+    field?: string | undefined;
+}, {
+    function: "min" | "max" | "count" | "sum" | "avg" | "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;
+        frame?: {
+            type?: "rows" | "range" | undefined;
+            start?: string | undefined;
+            end?: string | undefined;
+        } | undefined;
+    };
+    field?: string | undefined;
+}>;
 /**
  * Field Selection Node
  * Represents "Select" attributes, including joins.
@@ -46,8 +225,117 @@ export declare const QuerySchema: z.ZodObject<{
     object: z.ZodString;
     /** Select Clause */
     fields: z.ZodOptional<z.ZodArray<z.ZodType<any, z.ZodTypeDef, any>, "many">>;
+    /** Aggregations */
+    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>;
+    }, "strip", z.ZodTypeAny, {
+        function: "min" | "max" | "count" | "sum" | "avg" | "count_distinct" | "array_agg" | "string_agg";
+        alias: string;
+        field?: string | undefined;
+        distinct?: boolean | undefined;
+    }, {
+        function: "min" | "max" | "count" | "sum" | "avg" | "count_distinct" | "array_agg" | "string_agg";
+        alias: string;
+        field?: string | undefined;
+        distinct?: boolean | undefined;
+    }>, "many">>;
+    /** Window Functions */
+    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>;
+        alias: z.ZodString;
+        over: z.ZodObject<{
+            partitionBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            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">>;
+            frame: z.ZodOptional<z.ZodObject<{
+                type: z.ZodOptional<z.ZodEnum<["rows", "range"]>>;
+                start: z.ZodOptional<z.ZodString>;
+                end: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                type?: "rows" | "range" | undefined;
+                start?: string | undefined;
+                end?: string | undefined;
+            }, {
+                type?: "rows" | "range" | undefined;
+                start?: string | undefined;
+                end?: string | undefined;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            partitionBy?: string[] | undefined;
+            orderBy?: {
+                field: string;
+                order: "asc" | "desc";
+            }[] | undefined;
+            frame?: {
+                type?: "rows" | "range" | undefined;
+                start?: string | undefined;
+                end?: string | undefined;
+            } | undefined;
+        }, {
+            partitionBy?: string[] | undefined;
+            orderBy?: {
+                field: string;
+                order?: "asc" | "desc" | undefined;
+            }[] | undefined;
+            frame?: {
+                type?: "rows" | "range" | undefined;
+                start?: string | undefined;
+                end?: string | undefined;
+            } | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        function: "min" | "max" | "count" | "sum" | "avg" | "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;
+            frame?: {
+                type?: "rows" | "range" | undefined;
+                start?: string | undefined;
+                end?: string | undefined;
+            } | undefined;
+        };
+        field?: string | undefined;
+    }, {
+        function: "min" | "max" | "count" | "sum" | "avg" | "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;
+            frame?: {
+                type?: "rows" | "range" | undefined;
+                start?: string | undefined;
+                end?: string | undefined;
+            } | undefined;
+        };
+        field?: string | undefined;
+    }>, "many">>;
     /** Where Clause */
     filters: z.ZodOptional<z.ZodType<any, z.ZodTypeDef, any>>;
+    /** Joins */
+    joins: z.ZodOptional<z.ZodArray<z.ZodType<any, z.ZodTypeDef, any>, "many">>;
+    /** Group By Clause */
+    groupBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Having Clause */
+    having: z.ZodOptional<z.ZodType<any, z.ZodTypeDef, any>>;
     /** Order By Clause */
     sort: z.ZodOptional<z.ZodArray<z.ZodObject<{
         field: z.ZodString;
@@ -62,6 +350,8 @@ export declare const QuerySchema: z.ZodObject<{
     /** Pagination */
     top: z.ZodOptional<z.ZodNumber>;
     skip: z.ZodOptional<z.ZodNumber>;
+    /** Subquery flag */
+    distinct: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     object: string;
     sort?: {
@@ -69,7 +359,34 @@ export declare const QuerySchema: z.ZodObject<{
         order: "asc" | "desc";
     }[] | undefined;
     fields?: any[] | undefined;
+    distinct?: boolean | undefined;
+    aggregations?: {
+        function: "min" | "max" | "count" | "sum" | "avg" | "count_distinct" | "array_agg" | "string_agg";
+        alias: string;
+        field?: string | undefined;
+        distinct?: boolean | undefined;
+    }[] | undefined;
+    windowFunctions?: {
+        function: "min" | "max" | "count" | "sum" | "avg" | "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;
+            frame?: {
+                type?: "rows" | "range" | undefined;
+                start?: string | undefined;
+                end?: string | undefined;
+            } | undefined;
+        };
+        field?: string | undefined;
+    }[] | undefined;
     filters?: any;
+    joins?: any[] | undefined;
+    groupBy?: string[] | undefined;
+    having?: any;
     top?: number | undefined;
     skip?: number | undefined;
 }, {
@@ -79,11 +396,43 @@ export declare const QuerySchema: z.ZodObject<{
         order?: "asc" | "desc" | undefined;
     }[] | undefined;
     fields?: any[] | undefined;
+    distinct?: boolean | undefined;
+    aggregations?: {
+        function: "min" | "max" | "count" | "sum" | "avg" | "count_distinct" | "array_agg" | "string_agg";
+        alias: string;
+        field?: string | undefined;
+        distinct?: boolean | undefined;
+    }[] | undefined;
+    windowFunctions?: {
+        function: "min" | "max" | "count" | "sum" | "avg" | "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;
+            frame?: {
+                type?: "rows" | "range" | undefined;
+                start?: string | undefined;
+                end?: string | undefined;
+            } | undefined;
+        };
+        field?: string | undefined;
+    }[] | undefined;
     filters?: any;
+    joins?: any[] | undefined;
+    groupBy?: string[] | undefined;
+    having?: any;
     top?: number | undefined;
     skip?: number | undefined;
 }>;
 export type QueryAST = z.infer<typeof QuerySchema>;
+export type QueryInput = z.input<typeof QuerySchema>;
 export type FilterNode = z.infer<typeof FilterNodeSchema>;
 export type SortNode = z.infer<typeof SortNodeSchema>;
+export type AggregationNode = z.infer<typeof AggregationNodeSchema>;
+export type JoinNode = z.infer<typeof JoinNodeSchema>;
+export type WindowFunctionNode = z.infer<typeof WindowFunctionNodeSchema>;
+export type WindowSpec = z.infer<typeof WindowSpecSchema>;
 //# sourceMappingURL=query.zod.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"query.zod.d.ts","sourceRoot":"","sources":["../../src/data/query.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;GAGG;AACH,eAAO,MAAM,cAAc,iJAMzB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,aAAa,iCAA+B,CAAC;AAE1D;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,CAQ3C,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,cAAc;;;;;;;;;EAGzB,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,eAAe,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,CAS1C,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,WAAW;IACtB,oBAAoB;;IAGpB,oBAAoB;;IAGpB,mBAAmB;;IAGnB,sBAAsB;;;;;;;;;;;IAGtB,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;EAGjB,CAAC;AAEH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AACnD,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC1D,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC"}
+{"version":3,"file":"query.zod.d.ts","sourceRoot":"","sources":["../../src/data/query.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;GAGG;AACH,eAAO,MAAM,cAAc,iJAMzB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,aAAa,iCAA+B,CAAC;AAE1D;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,CAQ3C,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,cAAc;;;;;;;;;EAGzB,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,mBAAmB,+FAG9B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;EAKhC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,QAAQ,+CAA6C,CAAC;AAEnE;;;GAGG;AACH,eAAO,MAAM,cAAc,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,CAQzC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,cAAc,kJAIzB,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQ3B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKnC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,eAAe,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,CAS1C,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,WAAW;IACtB,oBAAoB;;IAGpB,oBAAoB;;IAGpB,mBAAmB;;;;;;;;;;;;;;;;;IAGnB,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAGvB,mBAAmB;;IAGnB,YAAY;;IAGZ,sBAAsB;;IAGtB,oBAAoB;;IAGpB,sBAAsB;;;;;;;;;;;IAGtB,iBAAiB;;;IAIjB,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEpB,CAAC;AAEH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AACnD,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AACrD,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC1D,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AACtD,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AACtD,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC"}

package/dist/data/query.zod.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.QuerySchema = exports.FieldNodeSchema = exports.SortNodeSchema = exports.FilterNodeSchema = exports.LogicOperator = exports.FilterOperator = void 0;
+exports.QuerySchema = exports.FieldNodeSchema = exports.WindowFunctionNodeSchema = exports.WindowSpecSchema = exports.WindowFunction = exports.JoinNodeSchema = exports.JoinType = exports.AggregationNodeSchema = exports.AggregationFunction = exports.SortNodeSchema = exports.FilterNodeSchema = exports.LogicOperator = exports.FilterOperator = void 0;
 const zod_1 = require("zod");
 /**
  * Filter Operator Enum
@@ -40,6 +40,70 @@ exports.SortNodeSchema = zod_1.z.object({
     field: zod_1.z.string(),
     order: zod_1.z.enum(['asc', 'desc']).default('asc')
 });
+/**
+ * Aggregation Function Enum
+ * Standard aggregation functions.
+ */
+exports.AggregationFunction = zod_1.z.enum([
+    'count', 'sum', 'avg', 'min', 'max',
+    'count_distinct', 'array_agg', 'string_agg'
+]);
+/**
+ * Aggregation Node
+ * Represents aggregated field with function.
+ */
+exports.AggregationNodeSchema = zod_1.z.object({
+    function: exports.AggregationFunction.describe('Aggregation function'),
+    field: zod_1.z.string().optional().describe('Field to aggregate (optional for COUNT(*))'),
+    alias: zod_1.z.string().describe('Result column alias'),
+    distinct: zod_1.z.boolean().optional().describe('Apply DISTINCT before aggregation'),
+});
+/**
+ * Join Type Enum
+ */
+exports.JoinType = zod_1.z.enum(['inner', 'left', 'right', 'full']);
+/**
+ * Join Node
+ * Represents table joins.
+ */
+exports.JoinNodeSchema = zod_1.z.lazy(() => zod_1.z.object({
+    type: exports.JoinType.describe('Join type'),
+    object: zod_1.z.string().describe('Object/table to join'),
+    alias: zod_1.z.string().optional().describe('Table alias'),
+    on: exports.FilterNodeSchema.describe('Join condition'),
+    subquery: zod_1.z.lazy(() => exports.QuerySchema).optional().describe('Subquery instead of object'),
+}));
+/**
+ * Window Function Enum
+ */
+exports.WindowFunction = zod_1.z.enum([
+    'row_number', 'rank', 'dense_rank', 'percent_rank',
+    'lag', 'lead', 'first_value', 'last_value',
+    'sum', 'avg', 'count', 'min', 'max'
+]);
+/**
+ * Window Specification
+ * Defines PARTITION BY and ORDER BY for window functions.
+ */
+exports.WindowSpecSchema = zod_1.z.object({
+    partitionBy: zod_1.z.array(zod_1.z.string()).optional().describe('PARTITION BY fields'),
+    orderBy: zod_1.z.array(exports.SortNodeSchema).optional().describe('ORDER BY specification'),
+    frame: zod_1.z.object({
+        type: zod_1.z.enum(['rows', 'range']).optional(),
+        start: zod_1.z.string().optional().describe('Frame start (e.g., "UNBOUNDED PRECEDING", "1 PRECEDING")'),
+        end: zod_1.z.string().optional().describe('Frame end (e.g., "CURRENT ROW", "1 FOLLOWING")'),
+    }).optional().describe('Window frame specification'),
+});
+/**
+ * Window Function Node
+ * Represents window function with OVER clause.
+ */
+exports.WindowFunctionNodeSchema = zod_1.z.object({
+    function: exports.WindowFunction.describe('Window function name'),
+    field: zod_1.z.string().optional().describe('Field to operate on (for aggregate window functions)'),
+    alias: zod_1.z.string().describe('Result column alias'),
+    over: exports.WindowSpecSchema.describe('Window specification (OVER clause)'),
+});
 /**
  * Field Selection Node
  * Represents "Select" attributes, including joins.
@@ -61,11 +125,23 @@ exports.QuerySchema = zod_1.z.object({
     object: zod_1.z.string().describe('Object name (e.g. account)'),
     /** Select Clause */
     fields: zod_1.z.array(exports.FieldNodeSchema).optional().describe('Fields to retrieve'),
+    /** Aggregations */
+    aggregations: zod_1.z.array(exports.AggregationNodeSchema).optional().describe('Aggregation functions (GROUP BY)'),
+    /** Window Functions */
+    windowFunctions: zod_1.z.array(exports.WindowFunctionNodeSchema).optional().describe('Window functions with OVER clause'),
     /** Where Clause */
     filters: exports.FilterNodeSchema.optional().describe('Filtering criteria'),
+    /** Joins */
+    joins: zod_1.z.array(exports.JoinNodeSchema).optional().describe('Table joins'),
+    /** Group By Clause */
+    groupBy: zod_1.z.array(zod_1.z.string()).optional().describe('GROUP BY fields'),
+    /** Having Clause */
+    having: exports.FilterNodeSchema.optional().describe('HAVING clause for aggregation filtering'),
     /** Order By Clause */
     sort: zod_1.z.array(exports.SortNodeSchema).optional().describe('Sorting instructions'),
     /** Pagination */
     top: zod_1.z.number().optional().describe('Limit results'),
     skip: zod_1.z.number().optional().describe('Offset results'),
+    /** Subquery flag */
+    distinct: zod_1.z.boolean().optional().describe('SELECT DISTINCT flag'),
 });