@object-ui/data-objectstack 0.5.0 → 3.0.0

package/src/index.ts

@@ -7,7 +7,7 @@
  */
 
 import { ObjectStackClient, type QueryOptions as ObjectStackQueryOptions } from '@objectstack/client';
-import type { DataSource, QueryParams, QueryResult } from '@object-ui/types';
+import type { DataSource, QueryParams, QueryResult, FileUploadResult } from '@object-ui/types';
 import { convertFiltersToAST } from '@object-ui/core';
 import { MetadataCache } from './cache/MetadataCache';
 import {
@@ -53,6 +53,9 @@ export type ConnectionStateListener = (event: ConnectionStateEvent) => void;
  */
 export type BatchProgressListener = (event: BatchProgressEvent) => void;
 
+// Re-export FileUploadResult from types for consumers
+export type { FileUploadResult } from '@object-ui/types';
+
 /**
  * ObjectStack Data Source Adapter
  * 
@@ -93,6 +96,8 @@ export class ObjectStackAdapter<T = unknown> implements DataSource<T> {
   private maxReconnectAttempts: number;
   private reconnectDelay: number;
   private reconnectAttempts: number = 0;
+  private baseUrl: string;
+  private token?: string;
 
   constructor(config: {
     baseUrl: string;
@@ -111,6 +116,8 @@ export class ObjectStackAdapter<T = unknown> implements DataSource<T> {
     this.autoReconnect = config.autoReconnect ?? true;
     this.maxReconnectAttempts = config.maxReconnectAttempts ?? 3;
     this.reconnectDelay = config.reconnectDelay ?? 1000;
+    this.baseUrl = config.baseUrl;
+    this.token = config.token;
   }
 
   /**
@@ -261,14 +268,16 @@ export class ObjectStackAdapter<T = unknown> implements DataSource<T> {
       };
     }
 
-    const resultObj = result as { value?: T[]; count?: number };
+    const resultObj = result as { records?: T[]; total?: number; value?: T[]; count?: number };
+    const records = resultObj.records || resultObj.value || [];
+    const total = resultObj.total ?? resultObj.count ?? records.length;
     return {
-      data: resultObj.value || [],
-      total: resultObj.count || (resultObj.value ? resultObj.value.length : 0),
+      data: records,
+      total,
       // Calculate page number safely
       page: params?.$skip && params.$top ? Math.floor(params.$skip / params.$top) + 1 : 1,
       pageSize: params?.$top,
-      hasMore: params?.$top ? (resultObj.value?.length || 0) === params.$top : false,
+      hasMore: params?.$top ? records.length === params.$top : false,
     };
   }
 
@@ -279,8 +288,8 @@ export class ObjectStackAdapter<T = unknown> implements DataSource<T> {
     await this.connect();
 
     try {
-      const record = await this.client.data.get<T>(resource, String(id));
-      return record;
+      const result = await this.client.data.get<T>(resource, String(id));
+      return result.record;
     } catch (error: unknown) {
       // If record not found, return null instead of throwing
       if ((error as Record<string, unknown>)?.status === 404) {
@@ -295,7 +304,8 @@ export class ObjectStackAdapter<T = unknown> implements DataSource<T> {
    */
   async create(resource: string, data: Partial<T>): Promise<T> {
     await this.connect();
-    return this.client.data.create<T>(resource, data);
+    const result = await this.client.data.create<T>(resource, data);
+    return result.record;
   }
 
   /**
@@ -303,7 +313,8 @@ export class ObjectStackAdapter<T = unknown> implements DataSource<T> {
    */
   async update(resource: string, id: string | number, data: Partial<T>): Promise<T> {
     await this.connect();
-    return this.client.data.update<T>(resource, String(id), data);
+    const result = await this.client.data.update<T>(resource, String(id), data);
+    return result.record;
   }
 
   /**
@@ -312,7 +323,7 @@ export class ObjectStackAdapter<T = unknown> implements DataSource<T> {
   async delete(resource: string, id: string | number): Promise<boolean> {
     await this.connect();
     const result = await this.client.data.delete(resource, String(id));
-    return result.success;
+    return result.deleted;
   }
 
   /**
@@ -416,7 +427,7 @@ export class ObjectStackAdapter<T = unknown> implements DataSource<T> {
             
             try {
               const result = await this.client.data.update<T>(resource, String(id), item);
-              results.push(result);
+              results.push(result.record);
               completed++;
               emitProgress();
             } catch (error: unknown) {
@@ -548,7 +559,7 @@ export class ObjectStackAdapter<T = unknown> implements DataSource<T> {
     try {
       // Use cache with automatic fetching
       const schema = await this.metadataCache.get(objectName, async () => {
-        const result: any = await this.client.meta.getObject(objectName);
+        const result: any = await this.client.meta.getItem('object', objectName);
         
         // Unwrap 'item' property if present (common API response wrapper)
         if (result && result.item) {
@@ -582,6 +593,132 @@ export class ObjectStackAdapter<T = unknown> implements DataSource<T> {
     return this.client;
   }
 
+  /**
+   * Get the discovery information from the connected server.
+   * Returns the capabilities and service status of the ObjectStack server.
+   * 
+   * Note: This accesses an internal property of the ObjectStackClient.
+   * The discovery data is populated during client.connect() and cached.
+   * 
+   * @returns Promise resolving to discovery data, or null if not connected
+   */
+  async getDiscovery(): Promise<unknown | null> {
+    try {
+      // Ensure we're connected first
+      await this.connect();
+      
+      // Access discovery data from the client
+      // The ObjectStackClient caches discovery during connect()
+      // This is an internal property, but documented for this use case
+      // @ts-expect-error - Accessing internal discoveryInfo property
+      return this.client.discoveryInfo || null;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Get a view definition for an object.
+   * Attempts to fetch from the server metadata API.
+   * Falls back to null if the server doesn't provide view definitions,
+   * allowing the consumer to use static config.
+   * 
+   * @param objectName - Object name
+   * @param viewId - View identifier
+   * @returns Promise resolving to the view definition or null
+   */
+  async getView(objectName: string, viewId: string): Promise<unknown | null> {
+    await this.connect();
+
+    try {
+      const cacheKey = `view:${objectName}:${viewId}`;
+      return await this.metadataCache.get(cacheKey, async () => {
+        // Try meta.getItem for view metadata
+        const result: any = await this.client.meta.getItem(objectName, `views/${viewId}`);
+        if (result && result.item) return result.item;
+        return result ?? null;
+      });
+    } catch {
+      // Server doesn't support view metadata — return null to fall back to static config
+      return null;
+    }
+  }
+
+  /**
+   * Get an application definition by name or ID.
+   * Attempts to fetch from the server metadata API.
+   * Falls back to null if the server doesn't provide app definitions,
+   * allowing the consumer to use static config.
+   * 
+   * @param appId - Application identifier
+   * @returns Promise resolving to the app definition or null
+   */
+  async getApp(appId: string): Promise<unknown | null> {
+    await this.connect();
+
+    try {
+      const cacheKey = `app:${appId}`;
+      return await this.metadataCache.get(cacheKey, async () => {
+        const result: any = await this.client.meta.getItem('apps', appId);
+        if (result && result.item) return result.item;
+        return result ?? null;
+      });
+    } catch {
+      // Server doesn't support app metadata — return null to fall back to static config
+      return null;
+    }
+  }
+
+  /**
+   * Get a page definition from ObjectStack.
+   * Uses the metadata API to fetch page layouts.
+   * Returns null if the server doesn't support page metadata.
+   */
+  async getPage(pageId: string): Promise<unknown | null> {
+    await this.connect();
+
+    try {
+      const cacheKey = `page:${pageId}`;
+      return await this.metadataCache.get(cacheKey, async () => {
+        const result: any = await this.client.meta.getItem('pages', pageId);
+        if (result && result.item) return result.item;
+        return result ?? null;
+      });
+    } catch {
+      // Server doesn't support page metadata — return null to fall back to static config
+      return null;
+    }
+  }
+
+  /**
+   * Get multiple metadata items from ObjectStack.
+   * Uses v3.0.0 metadata API pattern: getItems for batch retrieval.
+   */
+  async getItems(category: string, names: string[]): Promise<unknown[]> {
+    await this.connect();
+    
+    const results = await Promise.all(
+      names.map(async (name) => {
+        const cacheKey = `${category}:${name}`;
+        return this.metadataCache.get(cacheKey, async () => {
+          const result: any = await this.client.meta.getItem(category, name);
+          if (result && result.item) return result.item;
+          return result;
+        });
+      })
+    );
+    
+    return results;
+  }
+
+  /**
+   * Get cached metadata if available, without triggering a fetch.
+   * Uses v3.0.0 metadata API pattern: getCached for synchronous cache access.
+   */
+  getCached(key: string): unknown | undefined {
+    return this.metadataCache.getCachedSync(key);
+  }
+
   /**
    * Get cache statistics for monitoring performance.
    */
@@ -604,6 +741,131 @@ export class ObjectStackAdapter<T = unknown> implements DataSource<T> {
   clearCache(): void {
     this.metadataCache.clear();
   }
+
+  /**
+   * Upload a single file to a resource.
+   * Posts the file as multipart/form-data to the ObjectStack server.
+   *
+   * @param resource - The resource/object name to attach the file to
+   * @param file - File object or Blob to upload
+   * @param options - Additional upload options (recordId, fieldName, metadata)
+   * @returns Promise resolving to the upload result (file URL, metadata)
+   */
+  async uploadFile(
+    resource: string,
+    file: File | Blob,
+    options?: {
+      recordId?: string;
+      fieldName?: string;
+      metadata?: Record<string, unknown>;
+      onProgress?: (percent: number) => void;
+    },
+  ): Promise<FileUploadResult> {
+    await this.connect();
+
+    const formData = new FormData();
+    formData.append('file', file);
+
+    if (options?.recordId) {
+      formData.append('recordId', options.recordId);
+    }
+    if (options?.fieldName) {
+      formData.append('fieldName', options.fieldName);
+    }
+    if (options?.metadata) {
+      formData.append('metadata', JSON.stringify(options.metadata));
+    }
+
+    const url = `${this.baseUrl}/api/data/${encodeURIComponent(resource)}/upload`;
+
+    const response = await fetch(url, {
+      method: 'POST',
+      body: formData,
+      headers: {
+        ...(this.getAuthHeaders()),
+      },
+    });
+
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ message: response.statusText }));
+      throw new ObjectStackError(
+        error.message || `Upload failed with status ${response.status}`,
+        'UPLOAD_ERROR',
+        response.status,
+      );
+    }
+
+    return response.json();
+  }
+
+  /**
+   * Upload multiple files to a resource.
+   * Posts all files as a single multipart/form-data request.
+   *
+   * @param resource - The resource/object name to attach the files to
+   * @param files - Array of File objects or Blobs to upload
+   * @param options - Additional upload options
+   * @returns Promise resolving to array of upload results
+   */
+  async uploadFiles(
+    resource: string,
+    files: (File | Blob)[],
+    options?: {
+      recordId?: string;
+      fieldName?: string;
+      metadata?: Record<string, unknown>;
+      onProgress?: (percent: number) => void;
+    },
+  ): Promise<FileUploadResult[]> {
+    await this.connect();
+
+    const formData = new FormData();
+    files.forEach((file, idx) => {
+      formData.append(`files`, file, (file as File).name || `file-${idx}`);
+    });
+
+    if (options?.recordId) {
+      formData.append('recordId', options.recordId);
+    }
+    if (options?.fieldName) {
+      formData.append('fieldName', options.fieldName);
+    }
+    if (options?.metadata) {
+      formData.append('metadata', JSON.stringify(options.metadata));
+    }
+
+    const url = `${this.baseUrl}/api/data/${encodeURIComponent(resource)}/upload`;
+
+    const response = await fetch(url, {
+      method: 'POST',
+      body: formData,
+      headers: {
+        ...(this.getAuthHeaders()),
+      },
+    });
+
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ message: response.statusText }));
+      throw new ObjectStackError(
+        error.message || `Upload failed with status ${response.status}`,
+        'UPLOAD_ERROR',
+        response.status,
+      );
+    }
+
+    return response.json();
+  }
+
+  /**
+   * Get authorization headers from the adapter config.
+   */
+  private getAuthHeaders(): Record<string, string> {
+    const headers: Record<string, string> = {};
+    if (this.token) {
+      headers['Authorization'] = `Bearer ${this.token}`;
+    }
+    return headers;
+  }
 }
 
 /**
@@ -650,3 +912,19 @@ export {
 
 // Export cache types
 export type { CacheStats } from './cache/MetadataCache';
+
+// v3.0.0 Deep Integration modules
+export { CloudOperations } from './cloud';
+export type { CloudDeploymentConfig, CloudHostingConfig, CloudMarketplaceEntry } from './cloud';
+
+export { validatePluginContract, generateContractManifest } from './contracts';
+export type { PluginContract, PluginExport, PluginAPIContract, ContractValidationResult, ContractValidationError } from './contracts';
+
+export { IntegrationManager } from './integration';
+export type { IntegrationConfig, IntegrationTrigger, IntegrationProvider, SlackIntegrationConfig, EmailIntegrationConfig, WebhookIntegrationConfig } from './integration';
+
+export { SecurityManager } from './security';
+export type { SecurityPolicy, CSPConfig, AuditLogConfig, AuditEventType, DataMaskingConfig, DataMaskingRule, AuditLogEntry } from './security';
+
+export { createDefaultCanvasConfig, snapToGrid, calculateAutoLayout } from './studio';
+export type { StudioCanvasConfig, StudioPropertyEditor, StudioThemeBuilderConfig, StudioColorPalette, StudioTypographyPreset, StudioShadowPreset } from './studio';

package/src/integration.ts

@@ -0,0 +1,192 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/**
+ * Integration module for @objectstack/spec v3.0.0
+ * Provides third-party service connectors for Slack, email, webhooks.
+ */
+
+export type IntegrationProvider = 'slack' | 'email' | 'webhook' | 'teams' | 'discord';
+
+export interface IntegrationConfig {
+  /** Integration provider type */
+  provider: IntegrationProvider;
+  /** Whether this integration is enabled */
+  enabled: boolean;
+  /** Provider-specific configuration */
+  config: Record<string, unknown>;
+  /** Event triggers */
+  triggers?: IntegrationTrigger[];
+}
+
+export interface IntegrationTrigger {
+  /** Event name (e.g. 'record.created', 'record.updated') */
+  event: string;
+  /** Filter condition */
+  filter?: string;
+  /** Template for the message/payload */
+  template?: string;
+}
+
+export interface SlackIntegrationConfig extends IntegrationConfig {
+  provider: 'slack';
+  config: {
+    webhookUrl: string;
+    channel?: string;
+    username?: string;
+    iconEmoji?: string;
+  };
+}
+
+export interface EmailIntegrationConfig extends IntegrationConfig {
+  provider: 'email';
+  config: {
+    smtpHost: string;
+    smtpPort: number;
+    secure: boolean;
+    from: string;
+    to: string[];
+    subject?: string;
+  };
+}
+
+export interface WebhookIntegrationConfig extends IntegrationConfig {
+  provider: 'webhook';
+  config: {
+    url: string;
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH';
+    headers?: Record<string, string>;
+    retryCount?: number;
+    retryDelay?: number;
+  };
+}
+
+/**
+ * Integration service manager.
+ * Manages third-party service connections and event dispatching.
+ */
+export class IntegrationManager {
+  private integrations: Map<string, IntegrationConfig> = new Map();
+
+  /**
+   * Register a new integration.
+   */
+  register(id: string, config: IntegrationConfig): void {
+    this.integrations.set(id, config);
+  }
+
+  /**
+   * Remove an integration.
+   */
+  unregister(id: string): void {
+    this.integrations.delete(id);
+  }
+
+  /**
+   * Get all registered integrations.
+   */
+  getAll(): Map<string, IntegrationConfig> {
+    return new Map(this.integrations);
+  }
+
+  /**
+   * Get integrations that match a specific event.
+   */
+  getForEvent(event: string): IntegrationConfig[] {
+    return Array.from(this.integrations.values()).filter(
+      (integration) =>
+        integration.enabled &&
+        integration.triggers?.some((t) => t.event === event)
+    );
+  }
+
+  /**
+   * Dispatch an event to all matching integrations.
+   * Returns results for each integration.
+   */
+  async dispatch(event: string, payload: Record<string, unknown>): Promise<Array<{ id: string; success: boolean; error?: string }>> {
+    const matching = this.getForEvent(event);
+    const results: Array<{ id: string; success: boolean; error?: string }> = [];
+
+    for (const [id, integration] of this.integrations) {
+      if (!matching.includes(integration)) continue;
+      
+      try {
+        await this.send(integration, payload);
+        results.push({ id, success: true });
+      } catch (err) {
+        results.push({ id, success: false, error: (err as Error).message });
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Send payload to a specific integration.
+   */
+  private async send(integration: IntegrationConfig, payload: Record<string, unknown>): Promise<void> {
+    switch (integration.provider) {
+      case 'webhook': {
+        const cfg = integration.config as WebhookIntegrationConfig['config'];
+        const url = cfg.url;
+        // Validate URL - only allow http and https protocols
+        try {
+          const parsed = new URL(url);
+          if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+            throw new Error(`Invalid URL protocol: ${parsed.protocol}`);
+          }
+        } catch (e) {
+          if (e instanceof TypeError) {
+            throw new Error(`Invalid webhook URL: ${url}`);
+          }
+          throw e;
+        }
+        await fetch(url, {
+          method: cfg.method,
+          headers: {
+            'Content-Type': 'application/json',
+            ...cfg.headers,
+          },
+          body: JSON.stringify(payload),
+        });
+        break;
+      }
+      case 'slack': {
+        const cfg = integration.config as SlackIntegrationConfig['config'];
+        const url = cfg.webhookUrl;
+        // Validate URL - only allow https protocol for Slack webhooks
+        try {
+          const parsed = new URL(url);
+          if (parsed.protocol !== 'https:') {
+            throw new Error(`Invalid Slack webhook URL protocol: ${parsed.protocol}`);
+          }
+        } catch (e) {
+          if (e instanceof TypeError) {
+            throw new Error(`Invalid Slack webhook URL: ${url}`);
+          }
+          throw e;
+        }
+        await fetch(url, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            channel: cfg.channel,
+            username: cfg.username,
+            icon_emoji: cfg.iconEmoji,
+            text: JSON.stringify(payload),
+          }),
+        });
+        break;
+      }
+      // Email and other providers would require server-side implementation
+      default:
+        break;
+    }
+  }
+}