@object-ui/data-objectstack 0.5.0 → 3.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@object-ui/data-objectstack",
-  "version": "0.5.0",
+  "version": "3.0.0",
   "description": "ObjectStack Data Adapter for Object UI",
   "license": "MIT",
   "type": "module",
@@ -20,14 +20,14 @@
     "README.md"
   ],
   "dependencies": {
-    "@objectstack/client": "^0.9.1",
-    "@object-ui/core": "0.5.0",
-    "@object-ui/types": "0.5.0"
+    "@objectstack/client": "^3.0.2",
+    "@object-ui/core": "3.0.0",
+    "@object-ui/types": "3.0.0"
   },
   "devDependencies": {
-    "tsup": "^8.0.1",
-    "typescript": "^5.3.3",
-    "vitest": "^1.2.0"
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
   },
   "publishConfig": {
     "access": "public"

package/src/cache/MetadataCache.ts

@@ -204,6 +204,28 @@ export class MetadataCache {
     };
   }
 
+  /**
+   * Get a cached value synchronously without triggering a fetch.
+   * Returns undefined if not in cache or expired.
+   */
+  getCachedSync<V = unknown>(key: string): V | undefined {
+    const entry = this.cache.get(key);
+    if (!entry) return undefined;
+
+    // Check TTL
+    if (this.ttl > 0 && Date.now() - entry.timestamp > this.ttl) {
+      this.cache.delete(key);
+      return undefined;
+    }
+
+    // Update access order for LRU
+    this.cache.delete(key);
+    this.cache.set(key, entry);
+    this.stats.hits++;
+
+    return entry.data as V;
+  }
+
   /**
    * Check if a key exists in the cache (and is not expired)
    * 

package/src/cloud.ts

@@ -0,0 +1,109 @@
+/**
+ * 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.
+ */
+
+/**
+ * Cloud namespace integration for @objectstack/spec v3.0.0
+ * Replaces the legacy Hub namespace for cloud deployment, hosting, and marketplace schemas.
+ */
+
+export interface CloudDeploymentConfig {
+  /** Target environment */
+  environment: 'development' | 'staging' | 'production';
+  /** Cloud region */
+  region?: string;
+  /** Auto-scaling configuration */
+  scaling?: {
+    minInstances: number;
+    maxInstances: number;
+    targetCPU?: number;
+  };
+  /** Environment variables */
+  envVars?: Record<string, string>;
+}
+
+export interface CloudHostingConfig {
+  /** Custom domain */
+  customDomain?: string;
+  /** SSL configuration */
+  ssl?: {
+    enabled: boolean;
+    autoRenew: boolean;
+  };
+  /** CDN configuration */
+  cdn?: {
+    enabled: boolean;
+    regions?: string[];
+  };
+}
+
+export interface CloudMarketplaceEntry {
+  /** Plugin or app ID */
+  id: string;
+  /** Display name */
+  name: string;
+  /** Description */
+  description: string;
+  /** Version */
+  version: string;
+  /** Author */
+  author: string;
+  /** Category */
+  category: string;
+  /** Tags */
+  tags: string[];
+  /** Rating (1-5) */
+  rating?: number;
+  /** Install count */
+  installCount?: number;
+  /** Price (0 = free) */
+  price?: number;
+}
+
+/**
+ * Cloud operations helper for ObjectStack adapter.
+ * Provides methods for cloud deployment, hosting, and marketplace operations.
+ */
+export class CloudOperations {
+  constructor(private getClient: () => any) {}
+
+  /**
+   * Deploy an application to the cloud.
+   */
+  async deploy(appId: string, config: CloudDeploymentConfig): Promise<{ deploymentId: string; status: string }> {
+    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: string): Promise<{ status: string; url?: string }> {
+    const client = this.getClient();
+    const result = await client.cloud?.getDeployment?.(deploymentId);
+    return result ?? { status: 'unknown' };
+  }
+
+  /**
+   * Search marketplace entries.
+   */
+  async searchMarketplace(query?: string, category?: string): Promise<CloudMarketplaceEntry[]> {
+    const client = this.getClient();
+    const result = await client.cloud?.marketplace?.search?.({ query, category });
+    return result?.items ?? [];
+  }
+
+  /**
+   * Install a marketplace plugin.
+   */
+  async installPlugin(pluginId: string): Promise<{ success: boolean }> {
+    const client = this.getClient();
+    const result = await client.cloud?.marketplace?.install?.(pluginId);
+    return result ?? { success: false };
+  }
+}

package/src/connection.test.ts

@@ -98,3 +98,44 @@ describe('Batch Progress Events', () => {
     unsubscribe();
   });
 });
+
+describe('getDiscovery', () => {
+  it('should return discoveryInfo from the underlying client after connect', async () => {
+    const mockDiscovery = {
+      name: 'test-server',
+      version: '1.0.0',
+      services: {
+        auth: { enabled: false, status: 'unavailable' },
+        data: { enabled: true, status: 'available' },
+      },
+    };
+
+    const adapter = new ObjectStackAdapter({
+      baseUrl: 'http://localhost:3000',
+      autoReconnect: false,
+    });
+
+    // Mock the underlying client's connect method and discoveryInfo property
+    const client = adapter.getClient();
+    vi.spyOn(client, 'connect').mockResolvedValue(mockDiscovery as any);
+    // Simulate what connect() does: sets discoveryInfo
+    (client as any).discoveryInfo = mockDiscovery;
+
+    const discovery = await adapter.getDiscovery();
+    expect(discovery).toEqual(mockDiscovery);
+    expect((discovery as any)?.services?.auth?.enabled).toBe(false);
+  });
+
+  it('should return null when connection fails', async () => {
+    const adapter = new ObjectStackAdapter({
+      baseUrl: 'http://localhost:3000',
+      autoReconnect: false,
+    });
+
+    const client = adapter.getClient();
+    vi.spyOn(client, 'connect').mockRejectedValue(new Error('Connection failed'));
+
+    const discovery = await adapter.getDiscovery();
+    expect(discovery).toBeNull();
+  });
+});

package/src/contracts.ts

@@ -0,0 +1,115 @@
+/**
+ * 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.
+ */
+
+/**
+ * Contracts module integration for @objectstack/spec v3.0.0
+ * Provides plugin contract validation and marketplace publishing utilities.
+ */
+
+export interface PluginContract {
+  /** Plugin name */
+  name: string;
+  /** Plugin version */
+  version: string;
+  /** Required peer dependencies */
+  peerDependencies?: Record<string, string>;
+  /** Exported component types */
+  exports: PluginExport[];
+  /** Required permissions */
+  permissions?: string[];
+  /** API surface contract */
+  api?: PluginAPIContract;
+}
+
+export interface PluginExport {
+  /** Export name */
+  name: string;
+  /** Export type */
+  type: 'component' | 'hook' | 'utility' | 'provider';
+  /** Description */
+  description?: string;
+}
+
+export interface PluginAPIContract {
+  /** Consumed data sources */
+  dataSources?: string[];
+  /** Required object schemas */
+  requiredSchemas?: string[];
+  /** Event subscriptions */
+  events?: string[];
+}
+
+export interface ContractValidationResult {
+  valid: boolean;
+  errors: ContractValidationError[];
+  warnings: string[];
+}
+
+export interface ContractValidationError {
+  field: string;
+  message: string;
+  code: string;
+}
+
+/**
+ * Validate a plugin contract against the ObjectStack spec.
+ */
+export function validatePluginContract(contract: PluginContract): ContractValidationResult {
+  const errors: ContractValidationError[] = [];
+  const warnings: string[] = [];
+
+  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 — plugin will have minimal access');
+  }
+
+  return { valid: errors.length === 0, errors, warnings };
+}
+
+/**
+ * Generate a plugin contract manifest for marketplace publishing.
+ */
+export function generateContractManifest(contract: PluginContract): Record<string, unknown> {
+  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: new Date().toISOString(),
+  };
+}

package/src/errors.test.ts

@@ -270,7 +270,7 @@ describe('Error Helpers', () => {
 
       expect(error).toBeInstanceOf(MetadataNotFoundError);
       expect(error.statusCode).toBe(404);
-      expect((error as MetadataNotFoundError).details.objectName).toBe('users');
+      expect((error as MetadataNotFoundError).details?.objectName).toBe('users');
     });
 
     it('should create generic error for 404 without metadata context', () => {