@objectstack/spec 0.1.0 → 0.1.1

package/dist/system/api.zod.d.ts

@@ -0,0 +1,168 @@
+import { z } from 'zod';
+/**
+ * HTTP Method Enum
+ */
+export declare const HttpMethod: z.ZodEnum<["GET", "POST", "PUT", "DELETE", "PATCH"]>;
+/**
+ * Rate Limit Strategy
+ */
+export declare const RateLimitSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    windowMs: z.ZodDefault<z.ZodNumber>;
+    maxRequests: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    windowMs: number;
+    maxRequests: number;
+}, {
+    enabled?: boolean | undefined;
+    windowMs?: number | undefined;
+    maxRequests?: number | undefined;
+}>;
+/**
+ * API Mapping Schema
+ * Transform input/output data.
+ */
+export declare const ApiMappingSchema: z.ZodObject<{
+    source: z.ZodString;
+    target: z.ZodString;
+    transform: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    source: string;
+    target: string;
+    transform?: string | undefined;
+}, {
+    source: string;
+    target: string;
+    transform?: string | undefined;
+}>;
+/**
+ * API Endpoint Schema
+ * Defines an external facing API contract.
+ */
+export declare const ApiEndpointSchema: z.ZodObject<{
+    /** Identity */
+    name: z.ZodString;
+    path: z.ZodString;
+    method: z.ZodEnum<["GET", "POST", "PUT", "DELETE", "PATCH"]>;
+    /** Documentation */
+    summary: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    /** Execution Logic */
+    type: z.ZodEnum<["flow", "script", "object_operation", "proxy"]>;
+    target: z.ZodString;
+    /** Logic Config */
+    objectParams: z.ZodOptional<z.ZodObject<{
+        object: z.ZodOptional<z.ZodString>;
+        operation: z.ZodOptional<z.ZodEnum<["find", "get", "create", "update", "delete"]>>;
+    }, "strip", z.ZodTypeAny, {
+        object?: string | undefined;
+        operation?: "find" | "update" | "get" | "create" | "delete" | undefined;
+    }, {
+        object?: string | undefined;
+        operation?: "find" | "update" | "get" | "create" | "delete" | undefined;
+    }>>;
+    /** Data Transformation */
+    inputMapping: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        source: z.ZodString;
+        target: z.ZodString;
+        transform: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        source: string;
+        target: string;
+        transform?: string | undefined;
+    }, {
+        source: string;
+        target: string;
+        transform?: string | undefined;
+    }>, "many">>;
+    outputMapping: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        source: z.ZodString;
+        target: z.ZodString;
+        transform: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        source: string;
+        target: string;
+        transform?: string | undefined;
+    }, {
+        source: string;
+        target: string;
+        transform?: string | undefined;
+    }>, "many">>;
+    /** Policies */
+    authRequired: z.ZodDefault<z.ZodBoolean>;
+    rateLimit: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        windowMs: z.ZodDefault<z.ZodNumber>;
+        maxRequests: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        windowMs: number;
+        maxRequests: number;
+    }, {
+        enabled?: boolean | undefined;
+        windowMs?: number | undefined;
+        maxRequests?: number | undefined;
+    }>>;
+    cacheTtl: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    type: "script" | "flow" | "object_operation" | "proxy";
+    name: string;
+    target: string;
+    method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+    authRequired: boolean;
+    summary?: string | undefined;
+    description?: string | undefined;
+    objectParams?: {
+        object?: string | undefined;
+        operation?: "find" | "update" | "get" | "create" | "delete" | undefined;
+    } | undefined;
+    inputMapping?: {
+        source: string;
+        target: string;
+        transform?: string | undefined;
+    }[] | undefined;
+    outputMapping?: {
+        source: string;
+        target: string;
+        transform?: string | undefined;
+    }[] | undefined;
+    rateLimit?: {
+        enabled: boolean;
+        windowMs: number;
+        maxRequests: number;
+    } | undefined;
+    cacheTtl?: number | undefined;
+}, {
+    path: string;
+    type: "script" | "flow" | "object_operation" | "proxy";
+    name: string;
+    target: string;
+    method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+    summary?: string | undefined;
+    description?: string | undefined;
+    objectParams?: {
+        object?: string | undefined;
+        operation?: "find" | "update" | "get" | "create" | "delete" | undefined;
+    } | undefined;
+    inputMapping?: {
+        source: string;
+        target: string;
+        transform?: string | undefined;
+    }[] | undefined;
+    outputMapping?: {
+        source: string;
+        target: string;
+        transform?: string | undefined;
+    }[] | undefined;
+    authRequired?: boolean | undefined;
+    rateLimit?: {
+        enabled?: boolean | undefined;
+        windowMs?: number | undefined;
+        maxRequests?: number | undefined;
+    } | undefined;
+    cacheTtl?: number | undefined;
+}>;
+export type ApiEndpoint = z.infer<typeof ApiEndpointSchema>;
+//# sourceMappingURL=api.zod.d.ts.map

package/dist/system/api.zod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.zod.d.ts","sourceRoot":"","sources":["../../src/system/api.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AACH,eAAO,MAAM,UAAU,sDAAoD,CAAC;AAE5E;;GAEG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;EAI1B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;EAI3B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,iBAAiB;IAC5B,eAAe;;;;IAKf,oBAAoB;;;IAIpB,sBAAsB;;;IAItB,mBAAmB;;;;;;;;;;;IAMnB,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;IAI1B,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIf,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC"}

package/dist/system/api.zod.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiEndpointSchema = exports.ApiMappingSchema = exports.RateLimitSchema = exports.HttpMethod = void 0;
+const zod_1 = require("zod");
+/**
+ * HTTP Method Enum
+ */
+exports.HttpMethod = zod_1.z.enum(['GET', 'POST', 'PUT', 'DELETE', 'PATCH']);
+/**
+ * Rate Limit Strategy
+ */
+exports.RateLimitSchema = zod_1.z.object({
+    enabled: zod_1.z.boolean().default(false),
+    windowMs: zod_1.z.number().default(60000).describe('Time window in milliseconds'),
+    maxRequests: zod_1.z.number().default(100).describe('Max requests per window'),
+});
+/**
+ * API Mapping Schema
+ * Transform input/output data.
+ */
+exports.ApiMappingSchema = zod_1.z.object({
+    source: zod_1.z.string().describe('Source field/path'),
+    target: zod_1.z.string().describe('Target field/path'),
+    transform: zod_1.z.string().optional().describe('Transformation function name'),
+});
+/**
+ * API Endpoint Schema
+ * Defines an external facing API contract.
+ */
+exports.ApiEndpointSchema = zod_1.z.object({
+    /** Identity */
+    name: zod_1.z.string().regex(/^[a-z_][a-z0-9_]*$/).describe('Unique endpoint ID'),
+    path: zod_1.z.string().regex(/^\//).describe('URL Path (e.g. /api/v1/customers)'),
+    method: exports.HttpMethod.describe('HTTP Method'),
+    /** Documentation */
+    summary: zod_1.z.string().optional(),
+    description: zod_1.z.string().optional(),
+    /** Execution Logic */
+    type: zod_1.z.enum(['flow', 'script', 'object_operation', 'proxy']).describe('Implementation type'),
+    target: zod_1.z.string().describe('Target Flow ID, Script Name, or Proxy URL'),
+    /** Logic Config */
+    objectParams: zod_1.z.object({
+        object: zod_1.z.string().optional(),
+        operation: zod_1.z.enum(['find', 'get', 'create', 'update', 'delete']).optional(),
+    }).optional().describe('For object_operation type'),
+    /** Data Transformation */
+    inputMapping: zod_1.z.array(exports.ApiMappingSchema).optional().describe('Map Request Body to Internal Params'),
+    outputMapping: zod_1.z.array(exports.ApiMappingSchema).optional().describe('Map Internal Result to Response Body'),
+    /** Policies */
+    authRequired: zod_1.z.boolean().default(true).describe('Require authentication'),
+    rateLimit: exports.RateLimitSchema.optional().describe('Rate limiting policy'),
+    cacheTtl: zod_1.z.number().optional().describe('Response cache TTL in seconds'),
+});

package/dist/system/constants/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * ObjectStack Convention Constants
+ *
+ * This package defines the "Law of Location" - where things must be in ObjectStack packages.
+ * These paths are used by ObjectOS Runtime, ObjectStack CLI, and ObjectStudio IDE.
+ *
+ * Guiding Principle: "Strict Types, No Logic"
+ * This package has NO database connections, NO UI components, and NO runtime business logic.
+ */
+export * from './paths';
+//# sourceMappingURL=index.d.ts.map

package/dist/system/constants/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/system/constants/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,cAAc,SAAS,CAAC"}

package/dist/system/constants/index.js

@@ -0,0 +1,26 @@
+"use strict";
+/**
+ * ObjectStack Convention Constants
+ *
+ * This package defines the "Law of Location" - where things must be in ObjectStack packages.
+ * These paths are used by ObjectOS Runtime, ObjectStack CLI, and ObjectStudio IDE.
+ *
+ * Guiding Principle: "Strict Types, No Logic"
+ * This package has NO database connections, NO UI components, and NO runtime business logic.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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("./paths"), exports);

package/dist/system/constants/paths.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Package conventions and directory structure constants.
+ * These define the "Law of Location" - where things must be in ObjectStack packages.
+ *
+ * These paths are the source of truth used by:
+ * - ObjectOS Runtime (to locate package components)
+ * - ObjectStack CLI (to scaffold and validate packages)
+ * - ObjectStudio IDE (to provide intelligent navigation and validation)
+ */
+export declare const PKG_CONVENTIONS: {
+    /**
+     * Standard directories within ObjectStack packages.
+     * All packages MUST follow these conventions for the runtime to locate resources.
+     */
+    readonly DIRS: {
+        /**
+         * Location for schema definitions (Zod schemas, JSON schemas).
+         * Path: src/schemas
+         */
+        readonly SCHEMA: "src/schemas";
+        /**
+         * Location for server-side code and triggers.
+         * Path: src/server
+         */
+        readonly SERVER: "src/server";
+        /**
+         * Location for server-side trigger functions.
+         * Path: src/triggers
+         */
+        readonly TRIGGERS: "src/triggers";
+        /**
+         * Location for client-side code.
+         * Path: src/client
+         */
+        readonly CLIENT: "src/client";
+        /**
+         * Location for client-side page components.
+         * Path: src/client/pages
+         */
+        readonly PAGES: "src/client/pages";
+        /**
+         * Location for static assets (images, fonts, etc.).
+         * Path: assets
+         */
+        readonly ASSETS: "assets";
+    };
+    /**
+     * Standard file names within ObjectStack packages.
+     */
+    readonly FILES: {
+        /**
+         * Package manifest configuration file.
+         * File: objectstack.config.ts
+         */
+        readonly MANIFEST: "objectstack.config.ts";
+        /**
+         * Main entry point for the package.
+         * File: src/index.ts
+         */
+        readonly ENTRY: "src/index.ts";
+    };
+};
+/**
+ * Type helper to extract directory path values.
+ */
+export type PackageDirectory = typeof PKG_CONVENTIONS.DIRS[keyof typeof PKG_CONVENTIONS.DIRS];
+/**
+ * Type helper to extract file path values.
+ */
+export type PackageFile = typeof PKG_CONVENTIONS.FILES[keyof typeof PKG_CONVENTIONS.FILES];
+//# sourceMappingURL=paths.d.ts.map

package/dist/system/constants/paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../../src/system/constants/paths.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe;IAC1B;;;OAGG;;QAED;;;WAGG;;QAGH;;;WAGG;;QAGH;;;WAGG;;QAGH;;;WAGG;;QAGH;;;WAGG;;QAGH;;;WAGG;;;IAIL;;OAEG;;QAED;;;WAGG;;QAGH;;;WAGG;;;CAGG,CAAC;AAEX;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,OAAO,eAAe,CAAC,IAAI,CAAC,MAAM,OAAO,eAAe,CAAC,IAAI,CAAC,CAAC;AAE9F;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,OAAO,eAAe,CAAC,KAAK,CAAC,MAAM,OAAO,eAAe,CAAC,KAAK,CAAC,CAAC"}

package/dist/system/constants/paths.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PKG_CONVENTIONS = void 0;
+/**
+ * Package conventions and directory structure constants.
+ * These define the "Law of Location" - where things must be in ObjectStack packages.
+ *
+ * These paths are the source of truth used by:
+ * - ObjectOS Runtime (to locate package components)
+ * - ObjectStack CLI (to scaffold and validate packages)
+ * - ObjectStudio IDE (to provide intelligent navigation and validation)
+ */
+exports.PKG_CONVENTIONS = {
+    /**
+     * Standard directories within ObjectStack packages.
+     * All packages MUST follow these conventions for the runtime to locate resources.
+     */
+    DIRS: {
+        /**
+         * Location for schema definitions (Zod schemas, JSON schemas).
+         * Path: src/schemas
+         */
+        SCHEMA: 'src/schemas',
+        /**
+         * Location for server-side code and triggers.
+         * Path: src/server
+         */
+        SERVER: 'src/server',
+        /**
+         * Location for server-side trigger functions.
+         * Path: src/triggers
+         */
+        TRIGGERS: 'src/triggers',
+        /**
+         * Location for client-side code.
+         * Path: src/client
+         */
+        CLIENT: 'src/client',
+        /**
+         * Location for client-side page components.
+         * Path: src/client/pages
+         */
+        PAGES: 'src/client/pages',
+        /**
+         * Location for static assets (images, fonts, etc.).
+         * Path: assets
+         */
+        ASSETS: 'assets',
+    },
+    /**
+     * Standard file names within ObjectStack packages.
+     */
+    FILES: {
+        /**
+         * Package manifest configuration file.
+         * File: objectstack.config.ts
+         */
+        MANIFEST: 'objectstack.config.ts',
+        /**
+         * Main entry point for the package.
+         * File: src/index.ts
+         */
+        ENTRY: 'src/index.ts',
+    },
+};

package/dist/system/datasource.zod.d.ts

@@ -0,0 +1,127 @@
+import { z } from 'zod';
+/**
+ * Driver Type Enum
+ * Defines the underlying technology of the datasource.
+ */
+export declare const DriverType: z.ZodEnum<["postgres", "mysql", "sqlserver", "oracle", "sqlite", "mongo", "redis", "excel", "csv", "airtable", "rest_api", "graphql", "odata", "salesforce", "sap", "workday"]>;
+/**
+ * Datasource Capabilities Schema
+ * Declares what this datasource naturally supports.
+ * The ObjectQL engine uses this to determine what logic to push down
+ * and what to compute in memory.
+ */
+export declare const DatasourceCapabilities: z.ZodObject<{
+    /** Can execute SQL-like joins natively? */
+    joins: z.ZodDefault<z.ZodBoolean>;
+    /** Can handle ACID transactions? */
+    transactions: z.ZodDefault<z.ZodBoolean>;
+    /** Can perform full-text search? */
+    fullTextSearch: z.ZodDefault<z.ZodBoolean>;
+    /** Can perform aggregation (group by, sum, avg)? */
+    aggregation: z.ZodDefault<z.ZodBoolean>;
+    /** Is scheme-less (needs schema inference)? */
+    dynamicSchema: z.ZodDefault<z.ZodBoolean>;
+    /** Is read-only? */
+    readOnly: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    joins: boolean;
+    transactions: boolean;
+    fullTextSearch: boolean;
+    aggregation: boolean;
+    dynamicSchema: boolean;
+    readOnly: boolean;
+}, {
+    joins?: boolean | undefined;
+    transactions?: boolean | undefined;
+    fullTextSearch?: boolean | undefined;
+    aggregation?: boolean | undefined;
+    dynamicSchema?: boolean | undefined;
+    readOnly?: boolean | undefined;
+}>;
+/**
+ * Datasource Schema
+ * Represents a connection to an external data store.
+ */
+export declare const DatasourceSchema: z.ZodObject<{
+    /** Machine Name */
+    name: z.ZodString;
+    /** Human Label */
+    label: z.ZodOptional<z.ZodString>;
+    /** Driver */
+    driver: z.ZodEnum<["postgres", "mysql", "sqlserver", "oracle", "sqlite", "mongo", "redis", "excel", "csv", "airtable", "rest_api", "graphql", "odata", "salesforce", "sap", "workday"]>;
+    /**
+     * Connection Configuration
+     * Specific to the driver (e.g., host, port, user, password, bucket, etc.)
+     * Stored securely (passwords usually interpolated from ENV).
+     */
+    config: z.ZodRecord<z.ZodString, z.ZodAny>;
+    /**
+     * Capability Overrides
+     * Manually override what the driver claims to support.
+     */
+    capabilities: z.ZodOptional<z.ZodObject<{
+        /** Can execute SQL-like joins natively? */
+        joins: z.ZodDefault<z.ZodBoolean>;
+        /** Can handle ACID transactions? */
+        transactions: z.ZodDefault<z.ZodBoolean>;
+        /** Can perform full-text search? */
+        fullTextSearch: z.ZodDefault<z.ZodBoolean>;
+        /** Can perform aggregation (group by, sum, avg)? */
+        aggregation: z.ZodDefault<z.ZodBoolean>;
+        /** Is scheme-less (needs schema inference)? */
+        dynamicSchema: z.ZodDefault<z.ZodBoolean>;
+        /** Is read-only? */
+        readOnly: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        joins: boolean;
+        transactions: boolean;
+        fullTextSearch: boolean;
+        aggregation: boolean;
+        dynamicSchema: boolean;
+        readOnly: boolean;
+    }, {
+        joins?: boolean | undefined;
+        transactions?: boolean | undefined;
+        fullTextSearch?: boolean | undefined;
+        aggregation?: boolean | undefined;
+        dynamicSchema?: boolean | undefined;
+        readOnly?: boolean | undefined;
+    }>>;
+    /** Description */
+    description: z.ZodOptional<z.ZodString>;
+    /** Is enabled? */
+    active: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    active: boolean;
+    config: Record<string, any>;
+    driver: "csv" | "postgres" | "mysql" | "sqlserver" | "oracle" | "sqlite" | "mongo" | "redis" | "excel" | "airtable" | "rest_api" | "graphql" | "odata" | "salesforce" | "sap" | "workday";
+    label?: string | undefined;
+    description?: string | undefined;
+    capabilities?: {
+        joins: boolean;
+        transactions: boolean;
+        fullTextSearch: boolean;
+        aggregation: boolean;
+        dynamicSchema: boolean;
+        readOnly: boolean;
+    } | undefined;
+}, {
+    name: string;
+    config: Record<string, any>;
+    driver: "csv" | "postgres" | "mysql" | "sqlserver" | "oracle" | "sqlite" | "mongo" | "redis" | "excel" | "airtable" | "rest_api" | "graphql" | "odata" | "salesforce" | "sap" | "workday";
+    label?: string | undefined;
+    description?: string | undefined;
+    active?: boolean | undefined;
+    capabilities?: {
+        joins?: boolean | undefined;
+        transactions?: boolean | undefined;
+        fullTextSearch?: boolean | undefined;
+        aggregation?: boolean | undefined;
+        dynamicSchema?: boolean | undefined;
+        readOnly?: boolean | undefined;
+    } | undefined;
+}>;
+export type Datasource = z.infer<typeof DatasourceSchema>;
+export type DatasourceConfig = z.infer<typeof DatasourceCapabilities>;
+//# sourceMappingURL=datasource.zod.d.ts.map

package/dist/system/datasource.zod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"datasource.zod.d.ts","sourceRoot":"","sources":["../../src/system/datasource.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;GAGG;AACH,eAAO,MAAM,UAAU,iLAMrB,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB;IACjC,2CAA2C;;IAE3C,oCAAoC;;IAEpC,oCAAoC;;IAEpC,oDAAoD;;IAEpD,+CAA+C;;IAE/C,oBAAoB;;;;;;;;;;;;;;;;EAEpB,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,gBAAgB;IAC3B,mBAAmB;;IAGnB,kBAAkB;;IAGlB,aAAa;;IAGb;;;;OAIG;;IAGH;;;OAGG;;QAtCH,2CAA2C;;QAE3C,oCAAoC;;QAEpC,oCAAoC;;QAEpC,oDAAoD;;QAEpD,+CAA+C;;QAE/C,oBAAoB;;;;;;;;;;;;;;;;;IA+BpB,kBAAkB;;IAGlB,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAElB,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC1D,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC"}

package/dist/system/datasource.zod.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatasourceSchema = exports.DatasourceCapabilities = exports.DriverType = void 0;
+const zod_1 = require("zod");
+/**
+ * Driver Type Enum
+ * Defines the underlying technology of the datasource.
+ */
+exports.DriverType = zod_1.z.enum([
+    'postgres', 'mysql', 'sqlserver', 'oracle', 'sqlite', // SQL
+    'mongo', 'redis', // NoSQL
+    'excel', 'csv', 'airtable', // Spreadsheet / Low-code
+    'rest_api', 'graphql', 'odata', // Web Services
+    'salesforce', 'sap', 'workday' // Enterprise SaaS
+]);
+/**
+ * Datasource Capabilities Schema
+ * Declares what this datasource naturally supports.
+ * The ObjectQL engine uses this to determine what logic to push down
+ * and what to compute in memory.
+ */
+exports.DatasourceCapabilities = zod_1.z.object({
+    /** Can execute SQL-like joins natively? */
+    joins: zod_1.z.boolean().default(false),
+    /** Can handle ACID transactions? */
+    transactions: zod_1.z.boolean().default(false),
+    /** Can perform full-text search? */
+    fullTextSearch: zod_1.z.boolean().default(false),
+    /** Can perform aggregation (group by, sum, avg)? */
+    aggregation: zod_1.z.boolean().default(false),
+    /** Is scheme-less (needs schema inference)? */
+    dynamicSchema: zod_1.z.boolean().default(false),
+    /** Is read-only? */
+    readOnly: zod_1.z.boolean().default(false),
+});
+/**
+ * Datasource Schema
+ * Represents a connection to an external data store.
+ */
+exports.DatasourceSchema = zod_1.z.object({
+    /** Machine Name */
+    name: zod_1.z.string().regex(/^[a-z_][a-z0-9_]*$/).describe('Unique datasource identifier'),
+    /** Human Label */
+    label: zod_1.z.string().optional().describe('Display label'),
+    /** Driver */
+    driver: exports.DriverType.describe('Underlying driver type'),
+    /**
+     * Connection Configuration
+     * Specific to the driver (e.g., host, port, user, password, bucket, etc.)
+     * Stored securely (passwords usually interpolated from ENV).
+     */
+    config: zod_1.z.record(zod_1.z.any()).describe('Driver specific configuration'),
+    /**
+     * Capability Overrides
+     * Manually override what the driver claims to support.
+     */
+    capabilities: exports.DatasourceCapabilities.optional().describe('Capability overrides'),
+    /** Description */
+    description: zod_1.z.string().optional().describe('Internal description'),
+    /** Is enabled? */
+    active: zod_1.z.boolean().default(true).describe('Is datasource enabled'),
+});