@objectstack/spec 0.6.1 → 0.7.2

package/dist/shared/http.zod.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StaticMountSchema = exports.RateLimitConfigSchema = exports.CorsConfigSchema = exports.HttpMethod = void 0;
+const zod_1 = require("zod");
+/**
+ * Shared HTTP Schemas
+ *
+ * Common HTTP-related schemas used across API and System protocols.
+ * These schemas ensure consistency across different parts of the stack.
+ */
+// ==========================================
+// Basic HTTP Types
+// ==========================================
+/**
+ * HTTP Method Enum
+ */
+exports.HttpMethod = zod_1.z.enum([
+    'GET',
+    'POST',
+    'PUT',
+    'DELETE',
+    'PATCH',
+    'HEAD',
+    'OPTIONS'
+]);
+// ==========================================
+// CORS Configuration
+// ==========================================
+/**
+ * CORS Configuration Schema
+ * Cross-Origin Resource Sharing configuration
+ *
+ * Used by:
+ * - api/router.zod.ts (RouterConfigSchema)
+ * - system/http-server.zod.ts (HttpServerConfigSchema)
+ *
+ * @example
+ * {
+ *   "enabled": true,
+ *   "origins": ["http://localhost:3000", "https://app.example.com"],
+ *   "methods": ["GET", "POST", "PUT", "DELETE"],
+ *   "credentials": true,
+ *   "maxAge": 86400
+ * }
+ */
+exports.CorsConfigSchema = zod_1.z.object({
+    /**
+     * Enable CORS
+     */
+    enabled: zod_1.z.boolean().default(true).describe('Enable CORS'),
+    /**
+     * Allowed origins (* for all)
+     */
+    origins: zod_1.z.union([
+        zod_1.z.string(),
+        zod_1.z.array(zod_1.z.string())
+    ]).default('*').describe('Allowed origins (* for all)'),
+    /**
+     * Allowed HTTP methods
+     */
+    methods: zod_1.z.array(exports.HttpMethod).optional().describe('Allowed HTTP methods'),
+    /**
+     * Allow credentials (cookies, authorization headers)
+     */
+    credentials: zod_1.z.boolean().default(false).describe('Allow credentials (cookies, authorization headers)'),
+    /**
+     * Preflight cache duration in seconds
+     */
+    maxAge: zod_1.z.number().int().optional().describe('Preflight cache duration in seconds'),
+});
+// ==========================================
+// Rate Limiting
+// ==========================================
+/**
+ * Rate Limit Configuration Schema
+ *
+ * Used by:
+ * - api/endpoint.zod.ts (ApiEndpointSchema)
+ * - system/http-server.zod.ts (HttpServerConfigSchema)
+ *
+ * @example
+ * {
+ *   "enabled": true,
+ *   "windowMs": 60000,
+ *   "maxRequests": 100
+ * }
+ */
+exports.RateLimitConfigSchema = zod_1.z.object({
+    /**
+     * Enable rate limiting
+     */
+    enabled: zod_1.z.boolean().default(false).describe('Enable rate limiting'),
+    /**
+     * Time window in milliseconds
+     */
+    windowMs: zod_1.z.number().int().default(60000).describe('Time window in milliseconds'),
+    /**
+     * Max requests per window
+     */
+    maxRequests: zod_1.z.number().int().default(100).describe('Max requests per window'),
+});
+// ==========================================
+// Static File Serving
+// ==========================================
+/**
+ * Static Mount Configuration Schema
+ * Configuration for serving static files
+ *
+ * Used by:
+ * - api/router.zod.ts (RouterConfigSchema)
+ * - system/http-server.zod.ts (HttpServerConfigSchema)
+ *
+ * @example
+ * {
+ *   "path": "/static",
+ *   "directory": "./public",
+ *   "cacheControl": "public, max-age=31536000"
+ * }
+ */
+exports.StaticMountSchema = zod_1.z.object({
+    /**
+     * URL path to serve from
+     */
+    path: zod_1.z.string().describe('URL path to serve from'),
+    /**
+     * Physical directory to serve
+     */
+    directory: zod_1.z.string().describe('Physical directory to serve'),
+    /**
+     * Cache-Control header value
+     */
+    cacheControl: zod_1.z.string().optional().describe('Cache-Control header value'),
+});

package/dist/shared/index.d.ts

@@ -3,4 +3,6 @@
  * Common schemas used across multiple modules
  */
 export * from './identifiers.zod';
+export * from './mapping.zod';
+export * from './http.zod';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/shared/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,cAAc,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/shared/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,cAAc,mBAAmB,CAAC;AAClC,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC"}

package/dist/shared/index.js

@@ -19,3 +19,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./identifiers.zod"), exports);
+__exportStar(require("./mapping.zod"), exports);
+__exportStar(require("./http.zod"), exports);

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

@@ -0,0 +1,226 @@
+import { z } from 'zod';
+/**
+ * Base Field Mapping Protocol
+ *
+ * Shared by: ETL, Sync, Connector, External Lookup
+ *
+ * This module provides the canonical field mapping schema used across
+ * ObjectStack for data transformation and synchronization.
+ *
+ * **Use Cases:**
+ * - ETL pipelines (data/mapping.zod.ts)
+ * - Data synchronization (automation/sync.zod.ts)
+ * - Integration connectors (integration/connector.zod.ts)
+ * - External lookups (data/external-lookup.zod.ts)
+ *
+ * @example Basic field mapping
+ * ```typescript
+ * const mapping: FieldMapping = {
+ *   source: 'external_user_id',
+ *   target: 'user_id',
+ * };
+ * ```
+ *
+ * @example With transformation
+ * ```typescript
+ * const mapping: FieldMapping = {
+ *   source: 'user_name',
+ *   target: 'name',
+ *   transform: { type: 'cast', targetType: 'string' },
+ *   defaultValue: 'Unknown'
+ * };
+ * ```
+ */
+/**
+ * Transform Type Schema
+ *
+ * Defines the type of transformation to apply to a field value.
+ * Implementations can extend this for domain-specific transforms.
+ */
+export declare const TransformTypeSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"constant">;
+    value: z.ZodAny;
+}, "strip", z.ZodTypeAny, {
+    type: "constant";
+    value?: any;
+}, {
+    type: "constant";
+    value?: any;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"cast">;
+    targetType: z.ZodEnum<["string", "number", "boolean", "date"]>;
+}, "strip", z.ZodTypeAny, {
+    type: "cast";
+    targetType: "string" | "number" | "boolean" | "date";
+}, {
+    type: "cast";
+    targetType: "string" | "number" | "boolean" | "date";
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"lookup">;
+    table: z.ZodString;
+    keyField: z.ZodString;
+    valueField: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "lookup";
+    table: string;
+    keyField: string;
+    valueField: string;
+}, {
+    type: "lookup";
+    table: string;
+    keyField: string;
+    valueField: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"javascript">;
+    expression: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "javascript";
+    expression: string;
+}, {
+    type: "javascript";
+    expression: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"map">;
+    mappings: z.ZodRecord<z.ZodString, z.ZodAny>;
+}, "strip", z.ZodTypeAny, {
+    type: "map";
+    mappings: Record<string, any>;
+}, {
+    type: "map";
+    mappings: Record<string, any>;
+}>]>;
+export type TransformType = z.infer<typeof TransformTypeSchema>;
+/**
+ * Field Mapping Schema
+ *
+ * Base schema for mapping fields between source and target systems.
+ *
+ * **NAMING CONVENTION:**
+ * - source: Field name in the source system
+ * - target: Field name in the target system (should be snake_case for ObjectStack)
+ *
+ * @example
+ * ```typescript
+ * {
+ *   source: 'FirstName',
+ *   target: 'first_name',
+ *   transform: { type: 'cast', targetType: 'string' },
+ *   defaultValue: ''
+ * }
+ * ```
+ */
+export declare const FieldMappingSchema: z.ZodObject<{
+    /**
+     * Source field name
+     */
+    source: z.ZodString;
+    /**
+     * Target field name (should be snake_case for ObjectStack)
+     */
+    target: z.ZodString;
+    /**
+     * Transformation to apply
+     */
+    transform: z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"constant">;
+        value: z.ZodAny;
+    }, "strip", z.ZodTypeAny, {
+        type: "constant";
+        value?: any;
+    }, {
+        type: "constant";
+        value?: any;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"cast">;
+        targetType: z.ZodEnum<["string", "number", "boolean", "date"]>;
+    }, "strip", z.ZodTypeAny, {
+        type: "cast";
+        targetType: "string" | "number" | "boolean" | "date";
+    }, {
+        type: "cast";
+        targetType: "string" | "number" | "boolean" | "date";
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"lookup">;
+        table: z.ZodString;
+        keyField: z.ZodString;
+        valueField: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "lookup";
+        table: string;
+        keyField: string;
+        valueField: string;
+    }, {
+        type: "lookup";
+        table: string;
+        keyField: string;
+        valueField: string;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"javascript">;
+        expression: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "javascript";
+        expression: string;
+    }, {
+        type: "javascript";
+        expression: string;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"map">;
+        mappings: z.ZodRecord<z.ZodString, z.ZodAny>;
+    }, "strip", z.ZodTypeAny, {
+        type: "map";
+        mappings: Record<string, any>;
+    }, {
+        type: "map";
+        mappings: Record<string, any>;
+    }>]>>;
+    /**
+     * Default value if source is null/undefined
+     */
+    defaultValue: z.ZodOptional<z.ZodAny>;
+}, "strip", z.ZodTypeAny, {
+    source: string;
+    target: string;
+    transform?: {
+        type: "constant";
+        value?: any;
+    } | {
+        type: "cast";
+        targetType: "string" | "number" | "boolean" | "date";
+    } | {
+        type: "lookup";
+        table: string;
+        keyField: string;
+        valueField: string;
+    } | {
+        type: "javascript";
+        expression: string;
+    } | {
+        type: "map";
+        mappings: Record<string, any>;
+    } | undefined;
+    defaultValue?: any;
+}, {
+    source: string;
+    target: string;
+    transform?: {
+        type: "constant";
+        value?: any;
+    } | {
+        type: "cast";
+        targetType: "string" | "number" | "boolean" | "date";
+    } | {
+        type: "lookup";
+        table: string;
+        keyField: string;
+        valueField: string;
+    } | {
+        type: "javascript";
+        expression: string;
+    } | {
+        type: "map";
+        mappings: Record<string, any>;
+    } | undefined;
+    defaultValue?: any;
+}>;
+export type FieldMapping = z.infer<typeof FieldMappingSchema>;
+//# sourceMappingURL=mapping.zod.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mapping.zod.d.ts","sourceRoot":"","sources":["../../src/shared/mapping.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA2B9B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,kBAAkB;IAC7B;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAGH;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEH,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}

package/dist/shared/mapping.zod.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldMappingSchema = exports.TransformTypeSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Base Field Mapping Protocol
+ *
+ * Shared by: ETL, Sync, Connector, External Lookup
+ *
+ * This module provides the canonical field mapping schema used across
+ * ObjectStack for data transformation and synchronization.
+ *
+ * **Use Cases:**
+ * - ETL pipelines (data/mapping.zod.ts)
+ * - Data synchronization (automation/sync.zod.ts)
+ * - Integration connectors (integration/connector.zod.ts)
+ * - External lookups (data/external-lookup.zod.ts)
+ *
+ * @example Basic field mapping
+ * ```typescript
+ * const mapping: FieldMapping = {
+ *   source: 'external_user_id',
+ *   target: 'user_id',
+ * };
+ * ```
+ *
+ * @example With transformation
+ * ```typescript
+ * const mapping: FieldMapping = {
+ *   source: 'user_name',
+ *   target: 'name',
+ *   transform: { type: 'cast', targetType: 'string' },
+ *   defaultValue: 'Unknown'
+ * };
+ * ```
+ */
+/**
+ * Transform Type Schema
+ *
+ * Defines the type of transformation to apply to a field value.
+ * Implementations can extend this for domain-specific transforms.
+ */
+exports.TransformTypeSchema = zod_1.z.discriminatedUnion('type', [
+    zod_1.z.object({
+        type: zod_1.z.literal('constant'),
+        value: zod_1.z.any().describe('Constant value to use'),
+    }).describe('Set a constant value'),
+    zod_1.z.object({
+        type: zod_1.z.literal('cast'),
+        targetType: zod_1.z.enum(['string', 'number', 'boolean', 'date']).describe('Target data type'),
+    }).describe('Cast to a specific data type'),
+    zod_1.z.object({
+        type: zod_1.z.literal('lookup'),
+        table: zod_1.z.string().describe('Lookup table name'),
+        keyField: zod_1.z.string().describe('Field to match on'),
+        valueField: zod_1.z.string().describe('Field to retrieve'),
+    }).describe('Lookup value from another table'),
+    zod_1.z.object({
+        type: zod_1.z.literal('javascript'),
+        expression: zod_1.z.string().describe('JavaScript expression (e.g., "value.toUpperCase()")'),
+    }).describe('Custom JavaScript transformation'),
+    zod_1.z.object({
+        type: zod_1.z.literal('map'),
+        mappings: zod_1.z.record(zod_1.z.any()).describe('Value mappings (e.g., {"Active": "active"})'),
+    }).describe('Map values using a dictionary'),
+]);
+/**
+ * Field Mapping Schema
+ *
+ * Base schema for mapping fields between source and target systems.
+ *
+ * **NAMING CONVENTION:**
+ * - source: Field name in the source system
+ * - target: Field name in the target system (should be snake_case for ObjectStack)
+ *
+ * @example
+ * ```typescript
+ * {
+ *   source: 'FirstName',
+ *   target: 'first_name',
+ *   transform: { type: 'cast', targetType: 'string' },
+ *   defaultValue: ''
+ * }
+ * ```
+ */
+exports.FieldMappingSchema = zod_1.z.object({
+    /**
+     * Source field name
+     */
+    source: zod_1.z.string().describe('Source field name'),
+    /**
+     * Target field name (should be snake_case for ObjectStack)
+     */
+    target: zod_1.z.string().describe('Target field name'),
+    /**
+     * Transformation to apply
+     */
+    transform: exports.TransformTypeSchema.optional().describe('Transformation to apply'),
+    /**
+     * Default value if source is null/undefined
+     */
+    defaultValue: zod_1.z.any().optional().describe('Default if source is null/undefined'),
+});