@object-ui/data-objectstack 2.0.0 → 3.0.1

package/dist/index.cjs

@@ -24,15 +24,23 @@ var index_exports = {};
 __export(index_exports, {
   AuthenticationError: () => AuthenticationError,
   BulkOperationError: () => BulkOperationError,
+  CloudOperations: () => CloudOperations,
   ConnectionError: () => ConnectionError,
+  IntegrationManager: () => IntegrationManager,
   MetadataNotFoundError: () => MetadataNotFoundError,
   ObjectStackAdapter: () => ObjectStackAdapter,
   ObjectStackError: () => ObjectStackError,
+  SecurityManager: () => SecurityManager,
   ValidationError: () => ValidationError,
+  calculateAutoLayout: () => calculateAutoLayout,
+  createDefaultCanvasConfig: () => createDefaultCanvasConfig,
   createErrorFromResponse: () => createErrorFromResponse,
   createObjectStackAdapter: () => createObjectStackAdapter,
+  generateContractManifest: () => generateContractManifest,
   isErrorType: () => isErrorType,
-  isObjectStackError: () => isObjectStackError
+  isObjectStackError: () => isObjectStackError,
+  snapToGrid: () => snapToGrid,
+  validatePluginContract: () => validatePluginContract
 });
 module.exports = __toCommonJS(index_exports);
 var import_client = require("@objectstack/client");
@@ -157,6 +165,22 @@ var MetadataCache = class {
       hitRate
     };
   }
+  /**
+   * Get a cached value synchronously without triggering a fetch.
+   * Returns undefined if not in cache or expired.
+   */
+  getCachedSync(key) {
+    const entry = this.cache.get(key);
+    if (!entry) return void 0;
+    if (this.ttl > 0 && Date.now() - entry.timestamp > this.ttl) {
+      this.cache.delete(key);
+      return void 0;
+    }
+    this.cache.delete(key);
+    this.cache.set(key, entry);
+    this.stats.hits++;
+    return entry.data;
+  }
   /**
    * Check if a key exists in the cache (and is not expired)
    * 
@@ -364,6 +388,352 @@ function isErrorType(error, errorClass) {
   return error instanceof errorClass;
 }
 
+// src/cloud.ts
+var CloudOperations = class {
+  constructor(getClient) {
+    this.getClient = getClient;
+  }
+  /**
+   * Deploy an application to the cloud.
+   */
+  async deploy(appId, config) {
+    const client = this.getClient();
+    const result = await client.cloud?.deploy?.(appId, config);
+    return result ?? { deploymentId: `deploy-${Date.now()}`, status: "pending" };
+  }
+  /**
+   * Get deployment status.
+   */
+  async getDeploymentStatus(deploymentId) {
+    const client = this.getClient();
+    const result = await client.cloud?.getDeployment?.(deploymentId);
+    return result ?? { status: "unknown" };
+  }
+  /**
+   * Search marketplace entries.
+   */
+  async searchMarketplace(query, category) {
+    const client = this.getClient();
+    const result = await client.cloud?.marketplace?.search?.({ query, category });
+    return result?.items ?? [];
+  }
+  /**
+   * Install a marketplace plugin.
+   */
+  async installPlugin(pluginId) {
+    const client = this.getClient();
+    const result = await client.cloud?.marketplace?.install?.(pluginId);
+    return result ?? { success: false };
+  }
+};
+
+// src/contracts.ts
+function validatePluginContract(contract) {
+  const errors = [];
+  const warnings = [];
+  if (!contract.name || contract.name.trim().length === 0) {
+    errors.push({ field: "name", message: "Plugin name is required", code: "MISSING_NAME" });
+  }
+  if (!contract.version || !/^\d+\.\d+\.\d+/.test(contract.version)) {
+    errors.push({ field: "version", message: "Valid semver version is required", code: "INVALID_VERSION" });
+  }
+  if (!contract.exports || contract.exports.length === 0) {
+    errors.push({ field: "exports", message: "At least one export is required", code: "NO_EXPORTS" });
+  }
+  if (contract.exports) {
+    const validTypes = ["component", "hook", "utility", "provider"];
+    for (const exp of contract.exports) {
+      if (!exp.name) {
+        errors.push({ field: "exports.name", message: "Export name is required", code: "MISSING_EXPORT_NAME" });
+      }
+      if (!validTypes.includes(exp.type)) {
+        errors.push({ field: "exports.type", message: `Invalid export type: ${exp.type}`, code: "INVALID_EXPORT_TYPE" });
+      }
+    }
+  }
+  if (!contract.permissions || contract.permissions.length === 0) {
+    warnings.push("No permissions declared \u2014 plugin will have minimal access");
+  }
+  return { valid: errors.length === 0, errors, warnings };
+}
+function generateContractManifest(contract) {
+  return {
+    $schema: "https://objectui.org/schemas/plugin-contract-v1.json",
+    name: contract.name,
+    version: contract.version,
+    peerDependencies: contract.peerDependencies ?? {},
+    exports: contract.exports.map((exp) => ({
+      name: exp.name,
+      type: exp.type,
+      description: exp.description ?? ""
+    })),
+    permissions: contract.permissions ?? [],
+    api: contract.api ?? {},
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// src/integration.ts
+var IntegrationManager = class {
+  constructor() {
+    __publicField(this, "integrations", /* @__PURE__ */ new Map());
+  }
+  /**
+   * Register a new integration.
+   */
+  register(id, config) {
+    this.integrations.set(id, config);
+  }
+  /**
+   * Remove an integration.
+   */
+  unregister(id) {
+    this.integrations.delete(id);
+  }
+  /**
+   * Get all registered integrations.
+   */
+  getAll() {
+    return new Map(this.integrations);
+  }
+  /**
+   * Get integrations that match a specific event.
+   */
+  getForEvent(event) {
+    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, payload) {
+    const matching = this.getForEvent(event);
+    const results = [];
+    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.message });
+      }
+    }
+    return results;
+  }
+  /**
+   * Send payload to a specific integration.
+   */
+  async send(integration, payload) {
+    switch (integration.provider) {
+      case "webhook": {
+        const cfg = integration.config;
+        const url = cfg.url;
+        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;
+        const url = cfg.webhookUrl;
+        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;
+    }
+  }
+};
+
+// src/security.ts
+var SecurityManager = class {
+  constructor(policy = {}) {
+    __publicField(this, "policy");
+    __publicField(this, "auditLog", []);
+    this.policy = policy;
+  }
+  /**
+   * Generate a CSP header string from the configuration.
+   */
+  generateCSPHeader() {
+    const csp = this.policy.csp;
+    if (!csp) return "";
+    const directives = [];
+    if (csp.scriptSrc?.length) directives.push(`script-src ${csp.scriptSrc.join(" ")}`);
+    if (csp.styleSrc?.length) directives.push(`style-src ${csp.styleSrc.join(" ")}`);
+    if (csp.imgSrc?.length) directives.push(`img-src ${csp.imgSrc.join(" ")}`);
+    if (csp.connectSrc?.length) directives.push(`connect-src ${csp.connectSrc.join(" ")}`);
+    if (csp.fontSrc?.length) directives.push(`font-src ${csp.fontSrc.join(" ")}`);
+    if (csp.frameSrc?.length) directives.push(`frame-src ${csp.frameSrc.join(" ")}`);
+    if (csp.reportUri) directives.push(`report-uri ${csp.reportUri}`);
+    return directives.join("; ");
+  }
+  /**
+   * Record an audit log entry.
+   */
+  recordAudit(entry) {
+    if (!this.policy.auditLog?.enabled) return;
+    if (this.policy.auditLog.events && !this.policy.auditLog.events.includes(entry.event)) return;
+    const fullEntry = {
+      ...entry,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.auditLog.push(fullEntry);
+    const dest = this.policy.auditLog.destination ?? "console";
+    if (dest === "console" || dest === "both") {
+      console.info("[AUDIT]", fullEntry.event, fullEntry.userId, fullEntry.resource ?? "");
+    }
+  }
+  /**
+   * Get audit log entries.
+   */
+  getAuditLog(filter) {
+    let entries = [...this.auditLog];
+    if (filter?.event) entries = entries.filter((e) => e.event === filter.event);
+    if (filter?.userId) entries = entries.filter((e) => e.userId === filter.userId);
+    if (filter?.since) entries = entries.filter((e) => e.timestamp >= filter.since);
+    return entries;
+  }
+  /**
+   * Apply data masking to a record.
+   */
+  maskRecord(record, userRoles = []) {
+    if (!this.policy.dataMasking?.rules?.length) return record;
+    const masked = { ...record };
+    const maskChar = this.policy.dataMasking.maskChar ?? "*";
+    for (const rule of this.policy.dataMasking.rules) {
+      if (!(rule.field in masked) || masked[rule.field] == null) continue;
+      if (rule.exemptRoles?.some((role) => userRoles.includes(role))) continue;
+      const value = String(masked[rule.field]);
+      switch (rule.strategy) {
+        case "full":
+          masked[rule.field] = maskChar.repeat(value.length);
+          break;
+        case "partial": {
+          const visible = rule.visibleChars ?? 4;
+          if (value.length <= visible) {
+            masked[rule.field] = maskChar.repeat(value.length);
+          } else {
+            masked[rule.field] = value.slice(0, visible) + maskChar.repeat(value.length - visible);
+          }
+          break;
+        }
+        case "hash":
+          masked[rule.field] = `[HASHED:${simpleHash(value)}]`;
+          break;
+        case "redact":
+          masked[rule.field] = "[REDACTED]";
+          break;
+      }
+    }
+    return masked;
+  }
+  /**
+   * Update the security policy.
+   */
+  updatePolicy(policy) {
+    this.policy = { ...this.policy, ...policy };
+  }
+  /**
+   * Get current security policy.
+   */
+  getPolicy() {
+    return { ...this.policy };
+  }
+};
+function simpleHash(str) {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return Math.abs(hash).toString(36);
+}
+
+// src/studio.ts
+function createDefaultCanvasConfig(overrides) {
+  return {
+    width: 1200,
+    height: 800,
+    background: "grid",
+    gridSize: 8,
+    snapToGrid: true,
+    zoom: {
+      min: 0.25,
+      max: 3,
+      step: 0.1,
+      current: 1
+    },
+    panOffset: { x: 0, y: 0 },
+    showMinimap: false,
+    minimapPosition: "bottom-right",
+    ...overrides
+  };
+}
+function snapToGrid(x, y, gridSize) {
+  return {
+    x: Math.round(x / gridSize) * gridSize,
+    y: Math.round(y / gridSize) * gridSize
+  };
+}
+function calculateAutoLayout(items, canvasWidth, padding = 40, gap = 40) {
+  const positions = [];
+  let currentX = padding;
+  let currentY = padding;
+  let rowMaxHeight = 0;
+  for (const item of items) {
+    if (currentX + item.width + padding > canvasWidth) {
+      currentX = padding;
+      currentY += rowMaxHeight + gap;
+      rowMaxHeight = 0;
+    }
+    positions.push({ id: item.id, x: currentX, y: currentY });
+    currentX += item.width + gap;
+    rowMaxHeight = Math.max(rowMaxHeight, item.height);
+  }
+  return positions;
+}
+
 // src/index.ts
 var ObjectStackAdapter = class {
   constructor(config) {
@@ -510,13 +880,15 @@ var ObjectStackAdapter = class {
       };
     }
     const resultObj = result;
+    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
     };
   }
   /**
@@ -739,7 +1111,7 @@ var ObjectStackAdapter = class {
     await this.connect();
     try {
       const schema = await this.metadataCache.get(objectName, async () => {
-        const result = await this.client.meta.getObject(objectName);
+        const result = await this.client.meta.getItem("object", objectName);
         if (result && result.item) {
           return result.item;
         }
@@ -825,6 +1197,49 @@ var ObjectStackAdapter = class {
       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) {
+    await this.connect();
+    try {
+      const cacheKey = `page:${pageId}`;
+      return await this.metadataCache.get(cacheKey, async () => {
+        const result = await this.client.meta.getItem("pages", pageId);
+        if (result && result.item) return result.item;
+        return result ?? null;
+      });
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Get multiple metadata items from ObjectStack.
+   * Uses v3.0.0 metadata API pattern: getItems for batch retrieval.
+   */
+  async getItems(category, names) {
+    await this.connect();
+    const results = await Promise.all(
+      names.map(async (name) => {
+        const cacheKey = `${category}:${name}`;
+        return this.metadataCache.get(cacheKey, async () => {
+          const result = 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) {
+    return this.metadataCache.getCachedSync(key);
+  }
   /**
    * Get cache statistics for monitoring performance.
    */
@@ -945,13 +1360,21 @@ function createObjectStackAdapter(config) {
 0 && (module.exports = {
   AuthenticationError,
   BulkOperationError,
+  CloudOperations,
   ConnectionError,
+  IntegrationManager,
   MetadataNotFoundError,
   ObjectStackAdapter,
   ObjectStackError,
+  SecurityManager,
   ValidationError,
+  calculateAutoLayout,
+  createDefaultCanvasConfig,
   createErrorFromResponse,
   createObjectStackAdapter,
+  generateContractManifest,
   isErrorType,
-  isObjectStackError
+  isObjectStackError,
+  snapToGrid,
+  validatePluginContract
 });