@objectstack/spec 0.3.2 → 0.4.1

package/dist/automation/sync.zod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync.zod.d.ts","sourceRoot":"","sources":["../../src/automation/sync.zod.ts"],"names":[],"mappings":"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"}

package/dist/automation/sync.zod.js

@@ -0,0 +1,444 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Sync = exports.SyncExecutionResultSchema = exports.SyncExecutionStatusSchema = exports.DataSyncConfigSchema = exports.DataDestinationConfigSchema = exports.DataSourceConfigSchema = exports.FieldMappingSchema = exports.ConflictResolutionSchema = exports.SyncModeSchema = exports.SyncDirectionSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Data Sync Protocol
+ *
+ * Inspired by Salesforce Connect, Segment Sync, and Census Reverse ETL.
+ *
+ * Data sync provides bidirectional or unidirectional data synchronization
+ * between ObjectStack and external systems, maintaining data consistency
+ * across platforms.
+ *
+ * ## Use Cases
+ *
+ * 1. **CRM Integration**
+ *    - Sync contacts between ObjectStack and Salesforce
+ *    - Keep opportunity data synchronized
+ *    - Bidirectional updates
+ *
+ * 2. **Customer Data Platform (CDP)**
+ *    - Sync user profiles to Segment
+ *    - Enrichment data from Clearbit
+ *    - Marketing automation sync
+ *
+ * 3. **Operational Analytics**
+ *    - Sync production data to analytics warehouse
+ *    - Real-time dashboards
+ *    - Business intelligence
+ *
+ * @see https://help.salesforce.com/s/articleView?id=sf.platform_connect_about.htm
+ * @see https://segment.com/docs/connections/sync/
+ * @see https://www.getcensus.com/
+ *
+ * @example
+ * ```typescript
+ * const contactSync: DataSyncConfig = {
+ *   name: 'salesforce_contact_sync',
+ *   label: 'Salesforce Contact Sync',
+ *   source: {
+ *     object: 'contact',
+ *     filters: { status: 'active' }
+ *   },
+ *   destination: {
+ *     connector: 'salesforce',
+ *     operation: 'upsert_contact',
+ *     mapping: {
+ *       first_name: 'FirstName',
+ *       last_name: 'LastName',
+ *       email: 'Email'
+ *     }
+ *   },
+ *   syncMode: 'incremental',
+ *   schedule: '0 * * * *' // Hourly
+ * }
+ * ```
+ */
+/**
+ * Sync Direction
+ */
+exports.SyncDirectionSchema = zod_1.z.enum([
+    'push', // ObjectStack -> External (one-way)
+    'pull', // External -> ObjectStack (one-way)
+    'bidirectional', // Both directions
+]);
+/**
+ * Sync Mode
+ */
+exports.SyncModeSchema = zod_1.z.enum([
+    'full', // Full refresh every time
+    'incremental', // Only sync changed records
+    'realtime', // Real-time streaming sync
+]);
+/**
+ * Conflict Resolution Strategy
+ */
+exports.ConflictResolutionSchema = zod_1.z.enum([
+    'source_wins', // Source system always wins
+    'destination_wins', // Destination system always wins
+    'latest_wins', // Most recently modified wins
+    'manual', // Flag for manual resolution
+    'merge', // Smart merge (custom logic)
+]);
+/**
+ * Field Mapping Schema
+ *
+ * Maps fields between source and destination systems.
+ */
+exports.FieldMappingSchema = zod_1.z.object({
+    /**
+     * Source field name
+     */
+    sourceField: zod_1.z.string().describe('Source field name'),
+    /**
+     * Destination field name
+     */
+    destinationField: zod_1.z.string().describe('Destination field name'),
+    /**
+     * Transformation formula
+     * JavaScript expression to transform the value
+     *
+     * @example "value.toUpperCase()"
+     * @example "new Date(value).toISOString()"
+     */
+    transform: zod_1.z.string().optional().describe('Transformation formula'),
+    /**
+     * Default value if source is null/undefined
+     */
+    default: zod_1.z.any().optional().describe('Default value'),
+    /**
+     * Whether to sync null values
+     */
+    syncNull: zod_1.z.boolean().default(false).describe('Sync null values'),
+});
+/**
+ * Data Source Configuration
+ */
+exports.DataSourceConfigSchema = zod_1.z.object({
+    /**
+     * Source object name
+     * For ObjectStack objects
+     */
+    object: zod_1.z.string().optional().describe('ObjectStack object name'),
+    /**
+     * Filter conditions
+     * Only sync records matching these filters
+     */
+    filters: zod_1.z.any().optional().describe('Filter conditions'),
+    /**
+     * Fields to include
+     * If not specified, all fields are synced
+     */
+    fields: zod_1.z.array(zod_1.z.string()).optional().describe('Fields to sync'),
+    /**
+     * External connector instance ID
+     * For external data sources
+     */
+    connectorInstanceId: zod_1.z.string().optional().describe('Connector instance ID'),
+    /**
+     * External resource identifier
+     * e.g., Salesforce object name, database table, API endpoint
+     */
+    externalResource: zod_1.z.string().optional().describe('External resource ID'),
+});
+/**
+ * Data Destination Configuration
+ */
+exports.DataDestinationConfigSchema = zod_1.z.object({
+    /**
+     * Destination object name
+     * For ObjectStack objects
+     */
+    object: zod_1.z.string().optional().describe('ObjectStack object name'),
+    /**
+     * Connector instance ID
+     * For external destinations
+     */
+    connectorInstanceId: zod_1.z.string().optional().describe('Connector instance ID'),
+    /**
+     * Operation to perform
+     */
+    operation: zod_1.z.enum([
+        'insert', // Create new records only
+        'update', // Update existing records only
+        'upsert', // Insert or update based on key
+        'delete', // Delete records
+        'sync', // Full synchronization
+    ]).describe('Sync operation'),
+    /**
+     * Field mappings
+     * Maps source fields to destination fields
+     */
+    mapping: zod_1.z.union([
+        zod_1.z.record(zod_1.z.string()), // Simple mapping: { sourceField: 'destField' }
+        zod_1.z.array(exports.FieldMappingSchema), // Advanced mapping with transformations
+    ]).optional().describe('Field mappings'),
+    /**
+     * External resource identifier
+     */
+    externalResource: zod_1.z.string().optional().describe('External resource ID'),
+    /**
+     * Match key for upsert operations
+     * Fields to use for matching existing records
+     */
+    matchKey: zod_1.z.array(zod_1.z.string()).optional().describe('Match key fields'),
+});
+/**
+ * Data Sync Configuration Schema
+ *
+ * Complete definition of a data synchronization between systems.
+ */
+exports.DataSyncConfigSchema = zod_1.z.object({
+    /**
+     * Sync configuration name (snake_case)
+     */
+    name: zod_1.z.string()
+        .regex(/^[a-z_][a-z0-9_]*$/)
+        .describe('Sync configuration name (snake_case)'),
+    /**
+     * Human-readable label
+     */
+    label: zod_1.z.string().optional().describe('Sync display name'),
+    /**
+     * Description
+     */
+    description: zod_1.z.string().optional().describe('Sync description'),
+    /**
+     * Source configuration
+     */
+    source: exports.DataSourceConfigSchema.describe('Data source'),
+    /**
+     * Destination configuration
+     */
+    destination: exports.DataDestinationConfigSchema.describe('Data destination'),
+    /**
+     * Sync direction
+     */
+    direction: exports.SyncDirectionSchema.default('push').describe('Sync direction'),
+    /**
+     * Sync mode
+     */
+    syncMode: exports.SyncModeSchema.default('incremental').describe('Sync mode'),
+    /**
+     * Conflict resolution strategy
+     */
+    conflictResolution: exports.ConflictResolutionSchema
+        .default('latest_wins')
+        .describe('Conflict resolution'),
+    /**
+     * Execution schedule (cron expression)
+     * For scheduled syncs
+     *
+     * @example "0 * * * *" - Hourly
+     * @example "*\/15 * * * *" - Every 15 minutes
+     */
+    schedule: zod_1.z.string().optional().describe('Cron schedule'),
+    /**
+     * Whether sync is enabled
+     */
+    enabled: zod_1.z.boolean().default(true).describe('Sync enabled'),
+    /**
+     * Change tracking field
+     * Field to track when records were last modified
+     * Used for incremental sync
+     *
+     * @example "updated_at", "modified_date"
+     */
+    changeTrackingField: zod_1.z.string()
+        .optional()
+        .describe('Field for change tracking'),
+    /**
+     * Batch size
+     * Number of records to process per batch
+     */
+    batchSize: zod_1.z.number().int().min(1).max(10000)
+        .default(100)
+        .describe('Batch size for processing'),
+    /**
+     * Retry configuration
+     */
+    retry: zod_1.z.object({
+        maxAttempts: zod_1.z.number().int().min(0).default(3).describe('Max retries'),
+        backoffMs: zod_1.z.number().int().min(0).default(30000).describe('Backoff duration'),
+    }).optional().describe('Retry configuration'),
+    /**
+     * Pre-sync validation rules
+     */
+    validation: zod_1.z.object({
+        required: zod_1.z.array(zod_1.z.string()).optional().describe('Required fields'),
+        unique: zod_1.z.array(zod_1.z.string()).optional().describe('Unique constraint fields'),
+        custom: zod_1.z.array(zod_1.z.object({
+            name: zod_1.z.string(),
+            condition: zod_1.z.string().describe('Validation condition'),
+            message: zod_1.z.string().describe('Error message'),
+        })).optional().describe('Custom validation rules'),
+    }).optional().describe('Validation rules'),
+    /**
+     * Error handling configuration
+     */
+    errorHandling: zod_1.z.object({
+        onValidationError: zod_1.z.enum(['skip', 'fail', 'log']).default('skip'),
+        onSyncError: zod_1.z.enum(['skip', 'fail', 'retry']).default('retry'),
+        notifyOnError: zod_1.z.array(zod_1.z.string()).optional().describe('Email notifications'),
+    }).optional().describe('Error handling'),
+    /**
+     * Performance optimization
+     */
+    optimization: zod_1.z.object({
+        parallelBatches: zod_1.z.boolean().default(false).describe('Process batches in parallel'),
+        cacheEnabled: zod_1.z.boolean().default(true).describe('Enable caching'),
+        compressionEnabled: zod_1.z.boolean().default(false).describe('Enable compression'),
+    }).optional().describe('Performance optimization'),
+    /**
+     * Audit and logging
+     */
+    audit: zod_1.z.object({
+        logLevel: zod_1.z.enum(['none', 'error', 'warn', 'info', 'debug']).default('info'),
+        retainLogsForDays: zod_1.z.number().int().min(1).default(30),
+        trackChanges: zod_1.z.boolean().default(true).describe('Track all changes'),
+    }).optional().describe('Audit configuration'),
+    /**
+     * Tags for organization
+     */
+    tags: zod_1.z.array(zod_1.z.string()).optional().describe('Sync tags'),
+    /**
+     * Custom metadata
+     */
+    metadata: zod_1.z.record(zod_1.z.any()).optional().describe('Custom metadata'),
+});
+/**
+ * Sync Execution Status
+ */
+exports.SyncExecutionStatusSchema = zod_1.z.enum([
+    'pending', // Queued
+    'running', // Currently executing
+    'completed', // Successfully completed
+    'partial', // Completed with some errors
+    'failed', // Failed
+    'cancelled', // Manually cancelled
+]);
+/**
+ * Sync Execution Result Schema
+ *
+ * Result of a sync execution.
+ */
+exports.SyncExecutionResultSchema = zod_1.z.object({
+    /**
+     * Execution ID
+     */
+    id: zod_1.z.string().describe('Execution ID'),
+    /**
+     * Sync configuration name
+     */
+    syncName: zod_1.z.string().describe('Sync name'),
+    /**
+     * Execution status
+     */
+    status: exports.SyncExecutionStatusSchema.describe('Execution status'),
+    /**
+     * Start timestamp
+     */
+    startedAt: zod_1.z.string().datetime().describe('Start time'),
+    /**
+     * End timestamp
+     */
+    completedAt: zod_1.z.string().datetime().optional().describe('Completion time'),
+    /**
+     * Duration in milliseconds
+     */
+    durationMs: zod_1.z.number().optional().describe('Duration in ms'),
+    /**
+     * Statistics
+     */
+    stats: zod_1.z.object({
+        recordsProcessed: zod_1.z.number().int().default(0).describe('Total records processed'),
+        recordsInserted: zod_1.z.number().int().default(0).describe('Records inserted'),
+        recordsUpdated: zod_1.z.number().int().default(0).describe('Records updated'),
+        recordsDeleted: zod_1.z.number().int().default(0).describe('Records deleted'),
+        recordsSkipped: zod_1.z.number().int().default(0).describe('Records skipped'),
+        recordsErrored: zod_1.z.number().int().default(0).describe('Records with errors'),
+        conflictsDetected: zod_1.z.number().int().default(0).describe('Conflicts detected'),
+        conflictsResolved: zod_1.z.number().int().default(0).describe('Conflicts resolved'),
+    }).optional().describe('Execution statistics'),
+    /**
+     * Errors encountered
+     */
+    errors: zod_1.z.array(zod_1.z.object({
+        recordId: zod_1.z.string().optional().describe('Record ID'),
+        field: zod_1.z.string().optional().describe('Field name'),
+        message: zod_1.z.string().describe('Error message'),
+        code: zod_1.z.string().optional().describe('Error code'),
+    })).optional().describe('Errors'),
+    /**
+     * Execution logs
+     */
+    logs: zod_1.z.array(zod_1.z.string()).optional().describe('Execution logs'),
+});
+/**
+ * Helper factory for creating sync configurations
+ */
+exports.Sync = {
+    /**
+     * Create a simple object-to-object sync
+     */
+    objectSync: (params) => ({
+        name: params.name,
+        source: {
+            object: params.sourceObject,
+        },
+        destination: {
+            object: params.destObject,
+            operation: 'upsert',
+            mapping: params.mapping,
+        },
+        direction: 'push',
+        syncMode: 'incremental',
+        conflictResolution: 'latest_wins',
+        batchSize: 100,
+        schedule: params.schedule,
+        enabled: true,
+    }),
+    /**
+     * Create a connector sync
+     */
+    connectorSync: (params) => ({
+        name: params.name,
+        source: {
+            object: params.sourceObject,
+        },
+        destination: {
+            connectorInstanceId: params.connectorInstanceId,
+            externalResource: params.externalResource,
+            operation: 'upsert',
+            mapping: params.mapping,
+        },
+        direction: 'push',
+        syncMode: 'incremental',
+        conflictResolution: 'latest_wins',
+        batchSize: 100,
+        schedule: params.schedule,
+        enabled: true,
+    }),
+    /**
+     * Create a bidirectional sync
+     */
+    bidirectionalSync: (params) => ({
+        name: params.name,
+        source: {
+            object: params.object,
+        },
+        destination: {
+            connectorInstanceId: params.connectorInstanceId,
+            externalResource: params.externalResource,
+            operation: 'sync',
+            mapping: params.mapping,
+        },
+        direction: 'bidirectional',
+        syncMode: 'incremental',
+        conflictResolution: 'latest_wins',
+        batchSize: 100,
+        schedule: params.schedule,
+        enabled: true,
+    }),
+};

package/dist/{system → automation}/webhook.zod.d.ts

@@ -6,7 +6,19 @@ import { z } from 'zod';
 export declare const WebhookTriggerType: z.ZodEnum<["create", "update", "delete", "undelete", "api"]>;
 /**
  * Webhook Schema
- * outbound Integration: Push data to external URL when events happen.
+ * Outbound Integration: Push data to external URL when events happen.
+ *
+ * **NAMING CONVENTION:**
+ * Webhook names are machine identifiers and must be lowercase snake_case.
+ *
+ * @example Good webhook names
+ * - 'stripe_payment_sync'
+ * - 'slack_notification'
+ * - 'crm_lead_export'
+ *
+ * @example Bad webhook names (will be rejected)
+ * - 'StripePaymentSync' (PascalCase)
+ * - 'slackNotification' (camelCase)
  */
 export declare const WebhookSchema: z.ZodObject<{
     name: z.ZodString;
@@ -31,7 +43,7 @@ export declare const WebhookSchema: z.ZodObject<{
     url: string;
     name: string;
     method: "GET" | "POST" | "PUT";
-    triggers: ("create" | "update" | "delete" | "api" | "undelete")[];
+    triggers: ("update" | "delete" | "create" | "api" | "undelete")[];
     includeSession: boolean;
     retryCount: number;
     isActive: boolean;
@@ -43,7 +55,7 @@ export declare const WebhookSchema: z.ZodObject<{
     object: string;
     url: string;
     name: string;
-    triggers: ("create" | "update" | "delete" | "api" | "undelete")[];
+    triggers: ("update" | "delete" | "create" | "api" | "undelete")[];
     label?: string | undefined;
     method?: "GET" | "POST" | "PUT" | undefined;
     headers?: Record<string, string> | undefined;
@@ -56,6 +68,17 @@ export declare const WebhookSchema: z.ZodObject<{
 /**
  * Webhook Receiver Schema (Inbound)
  * Handling incoming HTTP hooks from Stripe, Slack, etc.
+ *
+ * **NAMING CONVENTION:**
+ * Webhook receiver names are machine identifiers and must be lowercase snake_case.
+ *
+ * @example Good names
+ * - 'stripe_webhook_handler'
+ * - 'github_events'
+ * - 'twilio_status_callback'
+ *
+ * @example Bad names (will be rejected)
+ * - 'StripeWebhookHandler' (PascalCase)
  */
 export declare const WebhookReceiverSchema: z.ZodObject<{
     name: z.ZodString;

package/dist/automation/webhook.zod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webhook.zod.d.ts","sourceRoot":"","sources":["../../src/automation/webhook.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;GAGG;AACH,eAAO,MAAM,kBAAkB,8DAM7B,CAAC;AAEH;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,aAAa;;;IAIxB,YAAY;;;IAIZ,aAAa;;;IAIb,eAAe;;;IAIf,4BAA4B;;;IAI5B,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGlB,CAAC;AAEH;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,qBAAqB;;;IAIhC,mBAAmB;;;;;;;;;;;;;;;IAQnB,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;EAGb,CAAC;AAEH,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AACpD,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC"}

package/dist/{system → automation}/webhook.zod.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebhookReceiverSchema = exports.WebhookSchema = exports.WebhookTriggerType = void 0;
 const zod_1 = require("zod");
+const identifiers_zod_1 = require("../shared/identifiers.zod");
 /**
  * Webhook Trigger Event
  * When should this webhook fire?
@@ -15,10 +16,22 @@ exports.WebhookTriggerType = zod_1.z.enum([
 ]);
 /**
  * Webhook Schema
- * outbound Integration: Push data to external URL when events happen.
+ * Outbound Integration: Push data to external URL when events happen.
+ *
+ * **NAMING CONVENTION:**
+ * Webhook names are machine identifiers and must be lowercase snake_case.
+ *
+ * @example Good webhook names
+ * - 'stripe_payment_sync'
+ * - 'slack_notification'
+ * - 'crm_lead_export'
+ *
+ * @example Bad webhook names (will be rejected)
+ * - 'StripePaymentSync' (PascalCase)
+ * - 'slackNotification' (camelCase)
  */
 exports.WebhookSchema = zod_1.z.object({
-    name: zod_1.z.string().regex(/^[a-z_][a-z0-9_]*$/),
+    name: identifiers_zod_1.SnakeCaseIdentifierSchema.describe('Webhook unique name (lowercase snake_case)'),
     label: zod_1.z.string().optional(),
     /** Scope */
     object: zod_1.z.string().describe('Object to listen to'),
@@ -39,9 +52,20 @@ exports.WebhookSchema = zod_1.z.object({
 /**
  * Webhook Receiver Schema (Inbound)
  * Handling incoming HTTP hooks from Stripe, Slack, etc.
+ *
+ * **NAMING CONVENTION:**
+ * Webhook receiver names are machine identifiers and must be lowercase snake_case.
+ *
+ * @example Good names
+ * - 'stripe_webhook_handler'
+ * - 'github_events'
+ * - 'twilio_status_callback'
+ *
+ * @example Bad names (will be rejected)
+ * - 'StripeWebhookHandler' (PascalCase)
  */
 exports.WebhookReceiverSchema = zod_1.z.object({
-    name: zod_1.z.string().regex(/^[a-z_][a-z0-9_]*$/),
+    name: identifiers_zod_1.SnakeCaseIdentifierSchema.describe('Webhook receiver unique name (lowercase snake_case)'),
     path: zod_1.z.string().describe('URL Path (e.g. /webhooks/stripe)'),
     /** Verification */
     verificationType: zod_1.z.enum(['none', 'header_token', 'hmac', 'ip_whitelist']).default('none'),