@origostudio/origo-design 0.0.0

package/packages/core/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@origo/core",
+  "version": "0.0.22",
+  "private": true,
+  "type": "commonjs",
+  "main": "./src/index.js",
+  "types": "./src/index.d.ts",
+  "dependencies": {
+    "ajv": "^8.17.1",
+    "ajv-errors": "^3.0.0",
+    "ajv-formats": "^3.0.1",
+    "json-schema-to-typescript": "^14.1.0",
+    "json-source-map": "^0.6.1",
+    "semver": "^7.7.4",
+    "tslib": "^2.3.0"
+  },
+  "devDependencies": {
+    "@types/json-source-map": "^0.6.0",
+    "@types/semver": "^7.8.0"
+  }
+}

package/packages/core/scripts/generate-types.ts

@@ -0,0 +1,23 @@
+import { compileFromFile } from 'json-schema-to-typescript';
+import * as fs from 'fs';
+import * as path from 'path';
+
+async function generate() {
+  const schemasDir = path.join(__dirname, '../src/schemas');
+  const typesDir = path.join(__dirname, '../src/types');
+
+  if (!fs.existsSync(typesDir)) {
+    fs.mkdirSync(typesDir, { recursive: true });
+  }
+
+  const domainTs = await compileFromFile(path.join(schemasDir, 'domain.schema.json'), {
+    cwd: schemasDir,
+    declareExternallyReferenced: true,
+  });
+  fs.writeFileSync(path.join(typesDir, 'domain.ts'), domainTs);
+}
+
+generate().catch(e => {
+  console.error(e);
+  process.exit(1);
+});

package/packages/core/src/extension-api/extension-manager.ts

@@ -0,0 +1,378 @@
+import { ExtensionManifest, ExtensionLifecycle, CorePermission, ExtensionContext } from './types';
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+import * as semver from 'semver';
+
+export class ExtensionError extends Error {
+  constructor(
+    message: string,
+    public readonly code: string
+  ) {
+    super(message);
+    this.name = 'ExtensionError';
+  }
+}
+
+export enum ExtensionState {
+  REGISTERED = 'REGISTERED',
+  INITIALIZED = 'INITIALIZED',
+  CONFIGURED = 'CONFIGURED',
+  VALIDATED = 'VALIDATED',
+  ACTIVATED = 'ACTIVATED',
+}
+
+export class ExtensionManager {
+  private extensions: Map<
+    string,
+    { manifest: ExtensionManifest; lifecycle: ExtensionLifecycle; state: ExtensionState }
+  > = new Map();
+  private capabilities: Set<string> = new Set();
+  private grantedPermissions: Map<string, Set<CorePermission>> = new Map();
+
+  public registerExtension(manifest: ExtensionManifest, lifecycle: ExtensionLifecycle) {
+    if (!manifest) throw new ExtensionError('Manifest is required', 'INVALID_MANIFEST');
+    if (!lifecycle) throw new ExtensionError('Lifecycle is required', 'INVALID_LIFECYCLE');
+    if (this.extensions.has(manifest.id)) {
+      throw new ExtensionError(
+        `Extension already registered: ${manifest.id}`,
+        'DUPLICATE_EXTENSION'
+      );
+    }
+    this.validateManifest(manifest);
+    this.grantedPermissions.set(manifest.id, new Set());
+    this.extensions.set(manifest.id, { manifest, lifecycle, state: ExtensionState.REGISTERED });
+  }
+
+  public registerCapability(capability: string) {
+    if (!/^[a-z0-9-]+:[a-z0-9-]+$/i.test(capability)) {
+      throw new ExtensionError(
+        `Invalid capability format: ${capability}. Must be namespace:name`,
+        'INVALID_CAPABILITY_NAMESPACE'
+      );
+    }
+    this.capabilities.add(capability);
+  }
+
+  private validateManifest(manifest: ExtensionManifest) {
+    if (!manifest.id || !manifest.name || !manifest.version || !manifest.type) {
+      throw new ExtensionError('Invalid manifest: missing required fields', 'INVALID_MANIFEST');
+    }
+    if (!semver.valid(manifest.version)) {
+      throw new ExtensionError(`Invalid semver version: ${manifest.version}`, 'INVALID_VERSION');
+    }
+
+    if (manifest.grammarRanges) {
+      if (typeof manifest.grammarRanges !== 'object' || Array.isArray(manifest.grammarRanges)) {
+        throw new ExtensionError('grammarRanges must be an object', 'INVALID_MANIFEST');
+      }
+      for (const [key, range] of Object.entries(manifest.grammarRanges)) {
+        if (typeof range !== 'string' || !semver.validRange(range)) {
+          throw new ExtensionError(
+            `Invalid semver range for grammar ${key}: ${range}`,
+            'INVALID_GRAMMAR_RANGE'
+          );
+        }
+      }
+    }
+
+    if (manifest.apiRanges) {
+      if (typeof manifest.apiRanges !== 'object' || Array.isArray(manifest.apiRanges)) {
+        throw new ExtensionError('apiRanges must be an object', 'INVALID_MANIFEST');
+      }
+      for (const [key, range] of Object.entries(manifest.apiRanges)) {
+        if (typeof range !== 'string' || !semver.validRange(range)) {
+          throw new ExtensionError(
+            `Invalid semver range for API ${key}: ${range}`,
+            'INVALID_API_RANGE'
+          );
+        }
+      }
+    }
+
+    if (manifest.dependencies) {
+      if (typeof manifest.dependencies !== 'object' || Array.isArray(manifest.dependencies)) {
+        throw new ExtensionError('dependencies must be an object', 'INVALID_MANIFEST');
+      }
+      for (const [key, range] of Object.entries(manifest.dependencies)) {
+        if (typeof range !== 'string' || !semver.validRange(range)) {
+          throw new ExtensionError(
+            `Invalid dependency range for ${key}: ${range}`,
+            'INVALID_DEPENDENCY_RANGE'
+          );
+        }
+      }
+    }
+
+    if (manifest.permissions !== undefined) {
+      if (
+        !Array.isArray(manifest.permissions) ||
+        manifest.permissions.some(p => typeof p !== 'string' || !p.trim())
+      ) {
+        throw new ExtensionError(
+          'permissions must be an array of non-empty strings',
+          'INVALID_MANIFEST'
+        );
+      }
+    }
+  }
+
+  private negotiateCapabilities(manifest: ExtensionManifest) {
+    if (manifest.capabilities) {
+      if (!Array.isArray(manifest.capabilities)) {
+        throw new ExtensionError('Capabilities must be an array', 'INVALID_MANIFEST');
+      }
+      for (const cap of manifest.capabilities) {
+        if (!this.capabilities.has(cap)) {
+          throw new ExtensionError(`Missing required capability: ${cap}`, 'MISSING_CAPABILITY');
+        }
+      }
+    }
+  }
+
+  public grantPermission(id: string, permission: CorePermission) {
+    const ext = this.extensions.get(id);
+    if (!ext) throw new ExtensionError(`Extension not found: ${id}`, 'NOT_FOUND');
+
+    if (ext.state !== ExtensionState.REGISTERED) {
+      throw new ExtensionError(
+        `Cannot grant permissions after extension initialization (current state: ${ext.state})`,
+        'INVALID_LIFECYCLE'
+      );
+    }
+
+    const declaredPermissions = ext.manifest.permissions || [];
+    if (!declaredPermissions.includes(permission)) {
+      throw new ExtensionError(
+        `Permission not declared in manifest: ${permission}`,
+        'UNDECLARED_PERMISSION'
+      );
+    }
+
+    const granted = this.grantedPermissions.get(id)!;
+    granted.add(permission);
+  }
+
+  public getDeclaredPermissions(id: string): CorePermission[] {
+    const ext = this.extensions.get(id);
+    if (!ext) throw new ExtensionError(`Extension not found: ${id}`, 'NOT_FOUND');
+    return ext.manifest.permissions || [];
+  }
+
+  public getGrantedPermissions(id: string): CorePermission[] {
+    const ext = this.extensions.get(id);
+    if (!ext) throw new ExtensionError(`Extension not found: ${id}`, 'NOT_FOUND');
+    return Array.from(this.grantedPermissions.get(id)!);
+  }
+
+  public hasPermission(id: string, permission: CorePermission): boolean {
+    const ext = this.extensions.get(id);
+    if (!ext) throw new ExtensionError(`Extension not found: ${id}`, 'NOT_FOUND');
+    return this.grantedPermissions.get(id)!.has(permission);
+  }
+
+  public checkPermission(id: string, permission: CorePermission) {
+    if (!this.hasPermission(id, permission)) {
+      throw new ExtensionError(
+        `Unauthorized access: Missing permission ${permission}`,
+        'UNAUTHORIZED_ACCESS'
+      );
+    }
+  }
+
+  private createSandboxContext(id: string, baseContext?: ExtensionContext): ExtensionContext {
+    const context = baseContext || {};
+    return {
+      getEnv: context.getEnv
+        ? (key: string) => {
+            this.checkPermission(id, 'env:read');
+            return context.getEnv!(key);
+          }
+        : undefined,
+      fetch: context.fetch
+        ? (((...args: Parameters<typeof fetch>) => {
+            this.checkPermission(id, 'network:fetch');
+            return context.fetch!(...args);
+          }) as typeof fetch)
+        : undefined,
+      readFile: context.readFile
+        ? (path: string) => {
+            this.checkPermission(id, 'fs:read');
+            return context.readFile!(path);
+          }
+        : undefined,
+      writeFile: context.writeFile
+        ? (path: string, data: string) => {
+            this.checkPermission(id, 'fs:write');
+            return context.writeFile!(path, data);
+          }
+        : undefined,
+    };
+  }
+
+  private enforcePermissionsBeforeExecution(manifest: ExtensionManifest) {
+    const id = manifest.id;
+    const declared = manifest.permissions || [];
+    const granted = this.grantedPermissions.get(id)!;
+
+    for (const perm of declared) {
+      if (!granted.has(perm)) {
+        throw new ExtensionError(
+          `Cannot execute extension ${id}: Missing required permission ${perm}`,
+          'UNAUTHORIZED_ACCESS'
+        );
+      }
+    }
+  }
+
+  public resolveDependencyGraph(): string[] {
+    const adjList = new Map<string, string[]>();
+
+    for (const [id, { manifest }] of this.extensions.entries()) {
+      const deps = manifest.dependencies ? Object.keys(manifest.dependencies) : [];
+
+      for (const [depId, range] of Object.entries(manifest.dependencies || {})) {
+        const target = this.extensions.get(depId);
+        if (!target) {
+          throw new ExtensionError(`Missing required dependency: ${depId}`, 'MISSING_DEPENDENCY');
+        }
+        if (!semver.satisfies(target.manifest.version, range)) {
+          throw new ExtensionError(
+            `Dependency version mismatch for ${depId}. Expected ${range}, got ${target.manifest.version}`,
+            'DEPENDENCY_VERSION_MISMATCH'
+          );
+        }
+      }
+
+      adjList.set(id, deps);
+    }
+
+    const visited = new Set<string>();
+    const visiting = new Set<string>();
+    const sorted: string[] = [];
+
+    const dfs = (node: string, path: string[]) => {
+      if (visiting.has(node)) {
+        const cycleStartIndex = path.indexOf(node);
+        const loop = cycleStartIndex >= 0 ? path.slice(cycleStartIndex) : path;
+        const cyclePath = [...loop, node].join(' -> ');
+        throw new ExtensionError(`Cyclic dependency detected: ${cyclePath}`, 'CYCLIC_DEPENDENCY');
+      }
+      if (visited.has(node)) return;
+
+      visiting.add(node);
+      path.push(node);
+
+      const deps = adjList.get(node) || [];
+      for (const dep of deps) {
+        dfs(dep, path);
+      }
+
+      path.pop();
+      visiting.delete(node);
+      visited.add(node);
+      sorted.push(node); // post-order (dependencies added before the node that depends on them)
+    };
+
+    for (const id of this.extensions.keys()) {
+      if (!visited.has(id)) {
+        dfs(id, []);
+      }
+    }
+
+    return sorted;
+  }
+
+  public async initializeExtension(id: string, context?: ExtensionContext) {
+    const ext = this.extensions.get(id);
+    if (!ext) throw new ExtensionError(`Extension not found: ${id}`, 'NOT_FOUND');
+    if (ext.state !== ExtensionState.REGISTERED) {
+      throw new ExtensionError(
+        `Cannot initialize extension in state ${ext.state}`,
+        'INVALID_LIFECYCLE'
+      );
+    }
+
+    this.enforcePermissionsBeforeExecution(ext.manifest);
+    this.negotiateCapabilities(ext.manifest);
+
+    const sandboxedContext = this.createSandboxContext(id, context);
+    await ext.lifecycle.initialize(sandboxedContext);
+    ext.state = ExtensionState.INITIALIZED;
+  }
+
+  public async configureExtension(id: string, config?: unknown) {
+    const ext = this.extensions.get(id);
+    if (!ext) throw new ExtensionError(`Extension not found: ${id}`, 'NOT_FOUND');
+    if (ext.state !== ExtensionState.INITIALIZED) {
+      throw new ExtensionError(
+        `Cannot configure extension in state ${ext.state}`,
+        'INVALID_LIFECYCLE'
+      );
+    }
+
+    this.enforcePermissionsBeforeExecution(ext.manifest);
+    await ext.lifecycle.configure(config);
+    ext.state = ExtensionState.CONFIGURED;
+  }
+
+  public async validateExtension(id: string) {
+    const ext = this.extensions.get(id);
+    if (!ext) throw new ExtensionError(`Extension not found: ${id}`, 'NOT_FOUND');
+    if (ext.state !== ExtensionState.CONFIGURED) {
+      throw new ExtensionError(
+        `Cannot validate extension in state ${ext.state}`,
+        'INVALID_LIFECYCLE'
+      );
+    }
+
+    this.enforcePermissionsBeforeExecution(ext.manifest);
+    const isValid = await ext.lifecycle.validate();
+    if (!isValid) {
+      throw new ExtensionError(`Extension failed validation: ${id}`, 'VALIDATION_FAILED');
+    }
+    ext.state = ExtensionState.VALIDATED;
+  }
+
+  public async activateExtension(id: string) {
+    const ext = this.extensions.get(id);
+    if (!ext) throw new ExtensionError(`Extension not found: ${id}`, 'NOT_FOUND');
+    if (ext.state !== ExtensionState.VALIDATED) {
+      throw new ExtensionError(
+        `Cannot activate extension in state ${ext.state}`,
+        'INVALID_LIFECYCLE'
+      );
+    }
+
+    this.enforcePermissionsBeforeExecution(ext.manifest);
+    await ext.lifecycle.activate();
+    ext.state = ExtensionState.ACTIVATED;
+  }
+
+  public async loadAll(context?: ExtensionContext, config?: unknown) {
+    const sortedIds = this.resolveDependencyGraph();
+
+    for (const id of sortedIds) {
+      if (this.getExtensionState(id) === ExtensionState.REGISTERED) {
+        await this.initializeExtension(id, context);
+      }
+    }
+    for (const id of sortedIds) {
+      if (this.getExtensionState(id) === ExtensionState.INITIALIZED) {
+        await this.configureExtension(id, config);
+      }
+    }
+    for (const id of sortedIds) {
+      if (this.getExtensionState(id) === ExtensionState.CONFIGURED) {
+        await this.validateExtension(id);
+      }
+    }
+    for (const id of sortedIds) {
+      if (this.getExtensionState(id) === ExtensionState.VALIDATED) {
+        await this.activateExtension(id);
+      }
+    }
+  }
+
+  public getExtensionState(id: string): ExtensionState | undefined {
+    return this.extensions.get(id)?.state;
+  }
+}

package/packages/core/src/extension-api/index.ts

@@ -0,0 +1,2 @@
+export * from './types';
+export * from './extension-manager';

package/packages/core/src/extension-api/types.ts

@@ -0,0 +1,37 @@
+export type CorePermission = 'network:fetch' | 'fs:read' | 'fs:write' | 'env:read';
+
+export interface ExtensionContext {
+  fetch?: typeof fetch;
+  readFile?: (path: string) => Promise<string>;
+  writeFile?: (path: string, data: string) => Promise<void>;
+  getEnv?: (key: string) => string | undefined;
+  [key: string]: unknown;
+}
+
+export interface ExtensionManifest {
+  /** The unique identifier of the extension */
+  id: string;
+  /** Name of the extension */
+  name: string;
+  /** Semantic version of the extension */
+  version: string;
+  /** Type of the extension */
+  type: string;
+  /** Grammar ranges required */
+  grammarRanges?: Record<string, string>;
+  /** API ranges required */
+  apiRanges?: Record<string, string>;
+  /** Capabilities required by this extension */
+  capabilities?: string[];
+  /** Permissions required by this extension for sandbox access */
+  permissions?: CorePermission[];
+  /** Dependencies on other extensions (map of extension id to semver range) */
+  dependencies?: Record<string, string>;
+}
+
+export interface ExtensionLifecycle {
+  initialize(context?: ExtensionContext): Promise<void> | void;
+  configure(config?: unknown): Promise<void> | void;
+  validate(): Promise<boolean> | boolean;
+  activate(): Promise<void> | void;
+}

package/packages/core/src/index.ts

@@ -0,0 +1,3 @@
+export * from './validator';
+export * from './types/domain';
+export * from './types/ast';

package/packages/core/src/schemas/__fixtures__/target-page.json

@@ -0,0 +1,222 @@
+{
+  "id": "page-user-management",
+  "name": "User Management Page",
+  "version": "1.0.0",
+  "domain": "User Management",
+  "entities": [
+    {
+      "id": "entity-user",
+      "name": "User",
+      "fields": [
+        {
+          "id": "field-user-id",
+          "name": "id",
+          "type": "string",
+          "label": "User ID",
+          "validation": ["required", "uuid"],
+          "metadata_path": "User.id"
+        },
+        {
+          "id": "field-user-username",
+          "name": "username",
+          "type": "string",
+          "label": "Username",
+          "validation": ["required", "minLength:3", "maxLength:50"],
+          "metadata_path": "User.username"
+        },
+        {
+          "id": "field-user-email",
+          "name": "email",
+          "type": "string",
+          "label": "Email Address",
+          "validation": ["required", "email"],
+          "metadata_path": "User.email"
+        },
+        {
+          "id": "field-user-isActive",
+          "name": "isActive",
+          "type": "boolean",
+          "label": "Active Status",
+          "validation": ["required"],
+          "metadata_path": "User.isActive"
+        },
+        {
+          "id": "field-user-createdAt",
+          "name": "createdAt",
+          "type": "date",
+          "label": "Creation Date",
+          "validation": ["required"],
+          "metadata_path": "User.createdAt"
+        },
+        {
+          "id": "field-user-roleId",
+          "name": "roleId",
+          "type": "string",
+          "label": "Role ID",
+          "references": "entity-role",
+          "validation": ["required"],
+          "metadata_path": "User.roleId"
+        },
+        {
+          "id": "field-user-departmentId",
+          "name": "departmentId",
+          "type": "string",
+          "label": "Department ID",
+          "references": "entity-department",
+          "validation": ["uuid"],
+          "metadata_path": "User.departmentId"
+        }
+      ]
+    },
+    {
+      "id": "entity-role",
+      "name": "Role",
+      "fields": [
+        {
+          "id": "field-role-id",
+          "name": "id",
+          "type": "string",
+          "label": "Role ID",
+          "validation": ["required", "uuid"],
+          "metadata_path": "Role.id"
+        },
+        {
+          "id": "field-role-name",
+          "name": "name",
+          "type": "string",
+          "label": "Role Name",
+          "validation": ["required"],
+          "metadata_path": "Role.name"
+        },
+        {
+          "id": "field-role-permissions",
+          "name": "permissions",
+          "type": "array",
+          "itemType": "string",
+          "label": "Permissions",
+          "validation": [],
+          "metadata_path": "Role.permissions"
+        }
+      ]
+    },
+    {
+      "id": "entity-department",
+      "name": "Department",
+      "fields": [
+        {
+          "id": "field-department-id",
+          "name": "id",
+          "type": "string",
+          "label": "Department ID",
+          "validation": ["required", "uuid"],
+          "metadata_path": "Department.id"
+        },
+        {
+          "id": "field-department-name",
+          "name": "name",
+          "type": "string",
+          "label": "Department Name",
+          "validation": ["required"],
+          "metadata_path": "Department.name"
+        }
+      ]
+    }
+  ],
+  "capabilities": [
+    {
+      "id": "cap-user-create",
+      "name": "Create",
+      "description": "Create a User",
+      "type": "Command",
+      "entityId": "entity-user",
+      "outcome_ref": ["outcome-1"],
+      "preconditions": ["pre-1"],
+      "postconditions": ["post-1"],
+      "permissions": [{ "role": "perm-1" }],
+      "risk_level": "medium",
+      "async": false
+    },
+    {
+      "id": "cap-user-read",
+      "name": "Read",
+      "description": "Read a User",
+      "type": "Query",
+      "entityId": "entity-user",
+      "outcome_ref": [],
+      "preconditions": [],
+      "postconditions": [],
+      "permissions": [{ "role": "admin" }],
+      "risk_level": "low",
+      "interaction_contract_ref": "ref",
+      "async": true
+    },
+    {
+      "id": "cap-user-update",
+      "name": "Update",
+      "description": "Update a User",
+      "type": "Command",
+      "entityId": "entity-user",
+      "outcome_ref": [],
+      "preconditions": [],
+      "postconditions": [],
+      "permissions": [{ "role": "admin" }],
+      "risk_level": "high",
+      "async": false
+    },
+    {
+      "id": "cap-user-delete",
+      "name": "Delete",
+      "description": "Delete a User",
+      "type": "Command",
+      "entityId": "entity-user",
+      "outcome_ref": [],
+      "preconditions": [],
+      "postconditions": [],
+      "permissions": [{ "role": "admin" }],
+      "risk_level": "critical",
+      "async": false
+    },
+    {
+      "id": "cap-user-list",
+      "name": "List",
+      "description": "List Users",
+      "type": "Query",
+      "entityId": "entity-user",
+      "outcome_ref": [],
+      "preconditions": [],
+      "postconditions": [],
+      "permissions": [{ "role": "admin" }],
+      "risk_level": "low",
+      "interaction_contract_ref": "ref",
+      "async": false
+    },
+    {
+      "id": "cap-role-list",
+      "name": "List",
+      "description": "List Roles",
+      "type": "Query",
+      "entityId": "entity-role",
+      "outcome_ref": [],
+      "preconditions": [],
+      "postconditions": [],
+      "permissions": [{ "role": "admin" }],
+      "risk_level": "low",
+      "interaction_contract_ref": "ref",
+      "async": false
+    },
+    {
+      "id": "cap-department-list",
+      "name": "List",
+      "description": "List Departments",
+      "type": "Query",
+      "entityId": "entity-department",
+      "outcome_ref": [],
+      "preconditions": [],
+      "postconditions": [],
+      "permissions": [{ "role": "admin" }],
+      "risk_level": "low",
+      "interaction_contract_ref": "ref",
+      "async": false
+    }
+  ]
+}