@burdenoff/be-sdk 2026.510.79

package/dist/chunk-F5XEAGHQ.js

@@ -0,0 +1,1875 @@
+import { shouldSyncRelationship, shouldSyncEntity, parseRelationship, getCollectionForEntity, extractMinimalFields, extractEntityTitle, createRelationshipEvent, createEntityEvent, addGraphExtension, GraphRegistry } from './chunk-TKBD2ONF.js';
+import { getGraphEventEmitter, NatsGraphEventEmitter } from './chunk-ELLX3K54.js';
+import { ValidationError } from './chunk-SAG6ZYWQ.js';
+import { logger } from './chunk-CBZNP6RF.js';
+import { __export, __name } from './chunk-XE4OXN2W.js';
+
+// src/graph/index.ts
+var graph_exports = {};
+__export(graph_exports, {
+  AUDIT_FIELDS: () => AUDIT_FIELDS,
+  GraphEventsPublisher: () => GraphEventsPublisher,
+  GraphExportService: () => GraphExportService,
+  GraphModule: () => GraphModule,
+  GraphRegistry: () => GraphRegistry,
+  SOFT_DELETE_FIELDS: () => SOFT_DELETE_FIELDS,
+  STANDARD_FIELDS: () => STANDARD_FIELDS,
+  TENANT_FIELDS: () => TENANT_FIELDS,
+  addGraphExtension: () => addGraphExtension,
+  createEntityEvent: () => createEntityEvent,
+  createGraphEventsHelper: () => createGraphEventsHelper,
+  createGraphExportService: () => createGraphExportService,
+  createPrismaGraphIntegration: () => createPrismaGraphIntegration,
+  createRelationshipEvent: () => createRelationshipEvent,
+  createRelationshipFromEntity: () => createRelationshipFromEntity,
+  defineEntity: () => defineEntity,
+  defineGraphConfig: () => defineGraphConfig,
+  defineModuleGraph: () => defineModuleGraph,
+  defineRelationship: () => defineRelationship,
+  extractEntityTitle: () => extractEntityTitle,
+  extractMinimalFields: () => extractMinimalFields,
+  getCollectionForEntity: () => getCollectionForEntity,
+  getGraphEventsPublisher: () => getGraphEventsPublisher,
+  getGraphStats: () => getGraphStats,
+  initializeGraph: () => initializeGraph,
+  isGraphInitialized: () => isGraphInitialized,
+  parseRelationship: () => parseRelationship,
+  shouldSyncEntity: () => shouldSyncEntity,
+  shouldSyncRelationship: () => shouldSyncRelationship
+});
+
+// src/graph/utils/prisma-helpers.ts
+function createPrismaGraphIntegration(options) {
+  const { serviceName, graphConfig, productName = "workspaces", validateRuntime = process.env.NODE_ENV !== "production", autoInit = true, createPrismaClient } = options;
+  const state = {
+    graphEmitter: null,
+    extendedPrismaClient: null,
+    emitterInitialized: false,
+    initializationPromise: null
+  };
+  async function initializeGraphEmitter() {
+    if (state.initializationPromise) {
+      return state.initializationPromise;
+    }
+    if (state.emitterInitialized) {
+      return;
+    }
+    state.initializationPromise = (async () => {
+      if (!process.env["GRAPH_EVENTS_ENABLED"] || process.env["GRAPH_EVENTS_ENABLED"] !== "true") {
+        logger.info(`[${serviceName}] Graph events disabled`);
+        state.emitterInitialized = true;
+        return;
+      }
+      try {
+        if (!process.env["NATS_SERVERS"] && process.env["NATS_URL"]) {
+          process.env["NATS_SERVERS"] = process.env["NATS_URL"];
+        }
+        state.graphEmitter = new NatsGraphEventEmitter();
+        logger.info(`[${serviceName}] Graph event emitter initialized`);
+        state.emitterInitialized = true;
+        const basePrisma = createPrismaClient();
+        state.extendedPrismaClient = initializeGraph(basePrisma, graphConfig, {
+          productName,
+          eventEmitter: state.graphEmitter,
+          enabled: true,
+          validateRuntime
+        });
+        logger.info(`[${serviceName}] Graph integration initialized successfully`);
+      } catch (error) {
+        logger.error(`[${serviceName}] Failed to initialize graph integration:`, error);
+        state.graphEmitter = null;
+        state.extendedPrismaClient = null;
+        state.emitterInitialized = true;
+      }
+    })();
+    return state.initializationPromise;
+  }
+  __name(initializeGraphEmitter, "initializeGraphEmitter");
+  function db() {
+    if (autoInit && !state.emitterInitialized && !state.initializationPromise) {
+      logger.warn(`[${serviceName}] Graph emitter not initialized before first database access. Auto-initializing now. Consider calling 'await initializeGraphEmitter()' explicitly during server startup for better control.`);
+      void initializeGraphEmitter();
+    }
+    if (!process.env["GRAPH_EVENTS_ENABLED"] || process.env["GRAPH_EVENTS_ENABLED"] !== "true" || !state.extendedPrismaClient) {
+      const baseClient = createPrismaClient();
+      return {
+        client: baseClient
+      };
+    }
+    return {
+      client: state.extendedPrismaClient
+    };
+  }
+  __name(db, "db");
+  const prisma = new Proxy({}, {
+    get(_, prop) {
+      const { client } = db();
+      const value = client[prop];
+      if (typeof value === "function") {
+        return value.bind(client);
+      }
+      return value;
+    }
+  });
+  async function cleanup() {
+    if (state.graphEmitter) {
+      await state.graphEmitter.disconnect();
+      logger.info(`[${serviceName}] Graph event emitter disconnected`);
+    }
+    if (state.extendedPrismaClient) {
+      await state.extendedPrismaClient.$disconnect();
+      state.extendedPrismaClient = null;
+      logger.info(`[${serviceName}] Prisma client disconnected`);
+    }
+    state.emitterInitialized = false;
+  }
+  __name(cleanup, "cleanup");
+  return {
+    /**
+    * Initialize graph event emitter
+    *
+    * With autoInit=true (default), this is called automatically on first database access.
+    * You can still call it manually for explicit initialization timing.
+    *
+    * With autoInit=false, you must call this during application startup.
+    */
+    initializeGraphEmitter,
+    /**
+    * Get Prisma client with graph integration
+    * Returns { client: PrismaClient }
+    *
+    * If autoInit is enabled, triggers initialization on first call.
+    */
+    db,
+    /**
+    * Direct Prisma client accessor (Proxy-based)
+    * Use this for most database operations
+    *
+    * If autoInit is enabled, initialization happens automatically.
+    */
+    prisma,
+    /**
+    * Cleanup function for graceful shutdown
+    */
+    cleanup,
+    /**
+    * Get the raw graph emitter instance (for advanced use cases)
+    */
+    getGraphEmitter: /* @__PURE__ */ __name(() => state.graphEmitter, "getGraphEmitter"),
+    /**
+    * Check if emitter is initialized
+    */
+    isInitialized: /* @__PURE__ */ __name(() => state.emitterInitialized, "isInitialized")
+  };
+}
+__name(createPrismaGraphIntegration, "createPrismaGraphIntegration");
+
+// src/graph/events-helper.ts
+var GraphEventsPublisher = class _GraphEventsPublisher {
+  static {
+    __name(this, "GraphEventsPublisher");
+  }
+  static instance = null;
+  productName;
+  initialized = false;
+  emitter = null;
+  constructor(productName = "unknown") {
+    this.productName = productName;
+  }
+  /**
+  * Get singleton instance
+  */
+  static getInstance(productName) {
+    if (!_GraphEventsPublisher.instance) {
+      _GraphEventsPublisher.instance = new _GraphEventsPublisher(productName);
+    }
+    return _GraphEventsPublisher.instance;
+  }
+  /**
+  * Set the product name (useful when using singleton)
+  */
+  setProductName(name) {
+    this.productName = name;
+  }
+  /**
+  * Initialize the publisher
+  */
+  async initialize() {
+    if (this.initialized) {
+      return;
+    }
+    try {
+      this.emitter = getGraphEventEmitter();
+      logger.info("[GraphEventsPublisher] Graph event emitter initialized");
+      this.initialized = true;
+      const natsUrl = process.env["NATS_URL"] || process.env["NATS_SERVERS"];
+      if (natsUrl) {
+        logger.info(`[GraphEventsPublisher] NATS configured: ${natsUrl}`);
+      } else {
+        logger.warn("[GraphEventsPublisher] NATS not configured, using in-memory fallback");
+      }
+    } catch (error) {
+      logger.error("[GraphEventsPublisher] Failed to initialize:", error);
+    }
+  }
+  /**
+  * Ensure initialized before publishing
+  */
+  async ensureInitialized() {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+  }
+  /**
+  * Publish entity created event
+  */
+  async publishEntityCreated(entity, options) {
+    await this.publishEntityEvent("entity.created", entity, options);
+  }
+  /**
+  * Publish entity updated event
+  */
+  async publishEntityUpdated(entity, options) {
+    await this.publishEntityEvent("entity.updated", entity, options);
+  }
+  /**
+  * Publish entity deleted event
+  */
+  async publishEntityDeleted(entity, options) {
+    await this.publishEntityEvent("entity.deleted", entity, options);
+  }
+  /**
+  * Publish relationship created event
+  */
+  async publishRelationshipCreated(relationship, organizationId, options) {
+    await this.publishRelationshipEvent("relationship.created", relationship, organizationId, options);
+  }
+  /**
+  * Publish relationship deleted event
+  */
+  async publishRelationshipDeleted(relationship, organizationId, options) {
+    await this.publishRelationshipEvent("relationship.deleted", relationship, organizationId, options);
+  }
+  /**
+  * Internal method to publish entity events
+  */
+  async publishEntityEvent(eventType, entity, options) {
+    await this.ensureInitialized();
+    if (!this.emitter) {
+      logger.warn("[GraphEventsPublisher] Emitter not initialized, skipping event");
+      return;
+    }
+    try {
+      await this.emitter.publishEntityEvent(eventType, {
+        id: entity.id,
+        type: entity.type,
+        data: entity.data
+      }, {
+        productName: this.productName,
+        organizationId: entity.organizationId || "unknown",
+        workspaceId: entity.workspaceId,
+        actorId: options?.userId
+      });
+      logger.debug(`[GraphEventsPublisher] Published ${eventType} for ${entity.type}:${entity.id}`);
+    } catch (error) {
+      logger.error(`[GraphEventsPublisher] Failed to publish ${eventType} for ${entity.type}:${entity.id}:`, error);
+    }
+  }
+  /**
+  * Internal method to publish relationship events
+  */
+  async publishRelationshipEvent(eventType, relationship, organizationId, options) {
+    await this.ensureInitialized();
+    if (!this.emitter) {
+      logger.warn("[GraphEventsPublisher] Emitter not initialized, skipping event");
+      return;
+    }
+    try {
+      await this.emitter.publishEntityEvent(eventType, {
+        id: `${relationship.from.id}_${relationship.to.id}`,
+        type: relationship.relationType,
+        data: {
+          from: relationship.from,
+          to: relationship.to,
+          metadata: relationship.metadata
+        }
+      }, {
+        productName: this.productName,
+        organizationId,
+        actorId: options?.userId
+      });
+      logger.debug(`[GraphEventsPublisher] Published ${eventType} for ${relationship.relationType}`);
+    } catch (error) {
+      logger.error(`[GraphEventsPublisher] Failed to publish ${eventType} for ${relationship.relationType}:`, error);
+    }
+  }
+  /**
+  * Shutdown the publisher
+  */
+  async shutdown() {
+    this.initialized = false;
+    this.emitter = null;
+    logger.info("[GraphEventsPublisher] Shutdown complete");
+  }
+  /**
+  * Reset singleton (for testing)
+  */
+  static reset() {
+    _GraphEventsPublisher.instance = null;
+  }
+};
+function getGraphEventsPublisher(productName) {
+  return GraphEventsPublisher.getInstance(productName);
+}
+__name(getGraphEventsPublisher, "getGraphEventsPublisher");
+function createGraphEventsHelper(config) {
+  const publisher = new GraphEventsPublisher(config.moduleName);
+  const helper = {};
+  for (const [name, entityConfig] of Object.entries(config.entities)) {
+    helper[name] = {
+      created: /* @__PURE__ */ __name(async (data, options) => {
+        await publisher.publishEntityCreated({
+          id: data["id"],
+          type: entityConfig.type,
+          data,
+          organizationId: entityConfig.getOrgId?.(data),
+          workspaceId: entityConfig.getWorkspaceId?.(data)
+        }, options);
+        if (entityConfig.onCreated) {
+          await entityConfig.onCreated(data, publisher, options);
+        }
+      }, "created"),
+      updated: /* @__PURE__ */ __name(async (data, options) => {
+        await publisher.publishEntityUpdated({
+          id: data["id"],
+          type: entityConfig.type,
+          data,
+          organizationId: entityConfig.getOrgId?.(data),
+          workspaceId: entityConfig.getWorkspaceId?.(data)
+        }, options);
+        if (entityConfig.onUpdated) {
+          await entityConfig.onUpdated(data, publisher, options);
+        }
+      }, "updated"),
+      deleted: /* @__PURE__ */ __name(async (data, options) => {
+        await publisher.publishEntityDeleted({
+          id: data["id"],
+          type: entityConfig.type,
+          data,
+          organizationId: entityConfig.getOrgId?.(data),
+          workspaceId: entityConfig.getWorkspaceId?.(data)
+        }, options);
+        if (entityConfig.onDeleted) {
+          await entityConfig.onDeleted(data, publisher, options);
+        }
+      }, "deleted")
+    };
+  }
+  return helper;
+}
+__name(createGraphEventsHelper, "createGraphEventsHelper");
+
+// src/graph/export-service.ts
+var GraphExportService = class {
+  static {
+    __name(this, "GraphExportService");
+  }
+  moduleName;
+  config;
+  fetchers;
+  relationshipFetchers;
+  customTransformer;
+  constructor(serviceConfig) {
+    this.moduleName = serviceConfig.moduleName;
+    this.config = serviceConfig.config;
+    this.fetchers = serviceConfig.fetchers;
+    this.relationshipFetchers = serviceConfig.relationshipFetchers || {};
+    this.customTransformer = serviceConfig.transformEntity;
+  }
+  /**
+  * Get the graph configuration schema
+  */
+  getSchema() {
+    const entities = {};
+    const relationships = {};
+    for (const [entityType, config] of Object.entries(this.config.entities)) {
+      entities[entityType] = {
+        fields: Array.isArray(config.fields) ? config.fields : [
+          "id",
+          "createdAt",
+          "updatedAt"
+        ],
+        collection: config.collection || "product_entities"
+      };
+    }
+    if (this.config.relationships) {
+      for (const [relType, config] of Object.entries(this.config.relationships)) {
+        relationships[relType] = {
+          from: config.from,
+          fromType: config.from,
+          to: config.to,
+          toType: config.to,
+          edgeType: config.label || "relates_to"
+        };
+      }
+    }
+    return {
+      moduleName: this.config.moduleName,
+      entities,
+      relationships
+    };
+  }
+  /**
+  * Export all entities for a given organization/workspace
+  */
+  async exportEntities(organizationId, workspaceId, entityTypes) {
+    const result = {};
+    const typesToExport = entityTypes || Object.keys(this.config.entities);
+    for (const entityType of typesToExport) {
+      if (!this.config.entities[entityType]) {
+        continue;
+      }
+      const fetcher = this.fetchers[entityType];
+      if (!fetcher) {
+        logger.warn(`[GraphExportService] No fetcher for ${entityType}`);
+        result[entityType] = [];
+        continue;
+      }
+      try {
+        const entities = await fetcher(organizationId, workspaceId);
+        result[entityType] = entities.map((item) => this.transformEntity(entityType, item));
+      } catch (error) {
+        logger.error(`[GraphExportService] Error fetching ${entityType}:`, error);
+        result[entityType] = [];
+      }
+    }
+    return result;
+  }
+  /**
+  * Export all relationships for a given organization/workspace
+  */
+  async exportRelationships(organizationId, workspaceId) {
+    const relationships = [];
+    for (const [name, fetcher] of Object.entries(this.relationshipFetchers)) {
+      try {
+        const rels = await fetcher(organizationId, workspaceId);
+        relationships.push(...rels);
+      } catch (error) {
+        logger.error(`[GraphExportService] Error fetching relationships ${name}:`, error);
+      }
+    }
+    return relationships;
+  }
+  /**
+  * Export complete graph data (schema + entities + relationships)
+  */
+  async exportAll(organizationId, workspaceId) {
+    const schema = this.getSchema();
+    const entities = await this.exportEntities(organizationId, workspaceId);
+    const relationships = await this.exportRelationships(organizationId, workspaceId);
+    const entityCounts = {};
+    let totalEntities = 0;
+    for (const [type, items] of Object.entries(entities)) {
+      entityCounts[type] = items.length;
+      totalEntities += items.length;
+    }
+    return {
+      moduleName: this.config.moduleName,
+      productSource: this.moduleName,
+      exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      schema: {
+        entities: schema.entities,
+        relationships: schema.relationships
+      },
+      data: {
+        entities,
+        relationships
+      },
+      stats: {
+        totalEntities,
+        totalRelationships: relationships.length,
+        entityCounts
+      }
+    };
+  }
+  /**
+  * Transform a database entity to graph export format
+  */
+  transformEntity(type, item) {
+    if (this.customTransformer) {
+      return this.customTransformer(type, item);
+    }
+    const { id, createdAt, updatedAt, workspaceId, tenantId, ...data } = item;
+    return {
+      id,
+      type,
+      data,
+      organizationId: tenantId,
+      workspaceId,
+      createdAt: createdAt instanceof Date ? createdAt.toISOString() : String(createdAt),
+      updatedAt: updatedAt instanceof Date ? updatedAt.toISOString() : String(updatedAt)
+    };
+  }
+};
+function createGraphExportService(config) {
+  return new GraphExportService(config);
+}
+__name(createGraphExportService, "createGraphExportService");
+function createRelationshipFromEntity(entity, relationConfig, relationType) {
+  const fromId = entity[relationConfig.from];
+  const toId = entity[relationConfig.to];
+  if (!fromId || !toId) {
+    return null;
+  }
+  const metadata = relationConfig.extractMetadata ? relationConfig.extractMetadata(entity) : {};
+  return {
+    id: `${relationType}_${entity["id"] || fromId}_${toId}`,
+    type: relationType,
+    fromId,
+    fromType: relationConfig.from || "Entity",
+    toId,
+    toType: relationConfig.to || "Entity",
+    metadata,
+    createdAt: entity["createdAt"] instanceof Date ? entity["createdAt"].toISOString() : String(entity["createdAt"] || (/* @__PURE__ */ new Date()).toISOString()),
+    updatedAt: entity["updatedAt"] instanceof Date ? entity["updatedAt"].toISOString() : String(entity["updatedAt"] || (/* @__PURE__ */ new Date()).toISOString())
+  };
+}
+__name(createRelationshipFromEntity, "createRelationshipFromEntity");
+
+// src/graph/module-graph.ts
+var GraphEventsPublisherInternal = class GraphEventsPublisherInternal2 {
+  static {
+    __name(this, "GraphEventsPublisherInternal");
+  }
+  productName;
+  initialized = false;
+  emitter = null;
+  constructor(productName) {
+    this.productName = productName;
+  }
+  async initialize() {
+    if (this.initialized) return;
+    try {
+      this.emitter = getGraphEventEmitter();
+      logger.info(`[ModuleGraph:${this.productName}] Graph event emitter initialized`);
+      this.initialized = true;
+      const natsUrl = process.env["NATS_URL"] || process.env["NATS_SERVERS"];
+      if (natsUrl) {
+        logger.info(`[ModuleGraph:${this.productName}] NATS configured: ${natsUrl}`);
+      } else {
+        logger.warn(`[ModuleGraph:${this.productName}] NATS not configured, using in-memory fallback`);
+      }
+    } catch (error) {
+      logger.error(`[ModuleGraph:${this.productName}] Failed to initialize:`, error);
+    }
+  }
+  async ensureInitialized() {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+  }
+  async publishEntityCreated(entity, options, rbac) {
+    await this.publishEntityEvent("entity.created", entity, options, rbac);
+  }
+  async publishEntityUpdated(entity, options, rbac) {
+    await this.publishEntityEvent("entity.updated", entity, options, rbac);
+  }
+  async publishEntityDeleted(entity, options, rbac) {
+    await this.publishEntityEvent("entity.deleted", entity, options, rbac);
+  }
+  async publishRelationshipCreated(relationship, organizationId, options) {
+    await this.publishRelationshipEvent("relationship.created", relationship, organizationId, options);
+  }
+  async publishRelationshipDeleted(relationship, organizationId, options) {
+    await this.publishRelationshipEvent("relationship.deleted", relationship, organizationId, options);
+  }
+  async publishEntityEvent(eventType, entity, options, rbac) {
+    await this.ensureInitialized();
+    if (!this.emitter) {
+      logger.warn(`[ModuleGraph:${this.productName}] Emitter not initialized, skipping event`);
+      return;
+    }
+    try {
+      await this.emitter.publishEntityEvent(eventType, {
+        id: entity.id,
+        type: entity.type,
+        data: entity.data
+      }, {
+        productName: this.productName,
+        organizationId: entity.organizationId || "unknown",
+        workspaceId: entity.workspaceId,
+        actorId: options?.actorId
+      }, rbac);
+      logger.debug(`[ModuleGraph:${this.productName}] Published ${eventType} for ${entity.type}:${entity.id}`, {
+        hasRbac: !!rbac
+      });
+    } catch (error) {
+      logger.error(`[ModuleGraph:${this.productName}] Failed to publish ${eventType}:`, error);
+    }
+  }
+  async publishRelationshipEvent(eventType, relationship, organizationId, options) {
+    await this.ensureInitialized();
+    if (!this.emitter) {
+      logger.warn(`[ModuleGraph:${this.productName}] Emitter not initialized, skipping event`);
+      return;
+    }
+    try {
+      await this.emitter.publishEntityEvent(eventType, {
+        id: `${relationship.from.id}_${relationship.to.id}`,
+        type: relationship.relationType,
+        data: {
+          from: relationship.from,
+          to: relationship.to,
+          metadata: relationship.metadata
+        }
+      }, {
+        productName: this.productName,
+        organizationId,
+        actorId: options?.actorId
+      });
+      logger.debug(`[ModuleGraph:${this.productName}] Published ${eventType} for ${relationship.relationType}`);
+    } catch (error) {
+      logger.error(`[ModuleGraph:${this.productName}] Failed to publish ${eventType}:`, error);
+    }
+  }
+  async shutdown() {
+    this.initialized = false;
+    this.emitter = null;
+    logger.info(`[ModuleGraph:${this.productName}] Shutdown complete`);
+  }
+};
+function defineModuleGraph(definition) {
+  const { moduleName, productSource, entities, relationships = {} } = definition;
+  const publisher = new GraphEventsPublisherInternal(productSource ?? moduleName);
+  const events = {};
+  for (const [entityName, entityDef] of Object.entries(entities)) {
+    const getOrgId = entityDef.getOrgId || (() => void 0);
+    const getWorkspaceId = entityDef.getWorkspaceId || (() => void 0);
+    const createEventContext = /* @__PURE__ */ __name(() => ({
+      publishRelationship: /* @__PURE__ */ __name(async (data, orgId) => {
+        await publisher.publishRelationshipCreated(data, orgId || "unknown");
+      }, "publishRelationship"),
+      deleteRelationship: /* @__PURE__ */ __name(async (data, orgId) => {
+        await publisher.publishRelationshipDeleted(data, orgId || "unknown");
+      }, "deleteRelationship"),
+      getOrgId,
+      getWorkspaceId
+    }), "createEventContext");
+    const buildRbacMetadata = /* @__PURE__ */ __name((data) => {
+      if (!entityDef.rbac) return void 0;
+      const rbacConfig = entityDef.rbac;
+      if (rbacConfig.createResource === false) return void 0;
+      const entityId = data["id"];
+      const title = data["name"] || data["title"] || data["label"] || entityId;
+      return {
+        resourceTypeName: rbacConfig.resourceTypeName,
+        name: rbacConfig.extractName?.(data) ?? title,
+        identifier: rbacConfig.extractIdentifier?.(data) ?? entityId,
+        parentResourceIdentifier: rbacConfig.parentResourceField ? data[rbacConfig.parentResourceField] : void 0,
+        createResource: rbacConfig.createResource ?? true
+      };
+    }, "buildRbacMetadata");
+    events[entityName] = {
+      created: /* @__PURE__ */ __name(async (data, options) => {
+        await publisher.publishEntityCreated({
+          id: data["id"],
+          type: entityDef.type,
+          data,
+          organizationId: getOrgId(data),
+          workspaceId: getWorkspaceId(data)
+        }, options, buildRbacMetadata(data));
+        if (entityDef.onCreated) {
+          await entityDef.onCreated(data, createEventContext(), options);
+        }
+      }, "created"),
+      updated: /* @__PURE__ */ __name(async (data, options) => {
+        await publisher.publishEntityUpdated({
+          id: data["id"],
+          type: entityDef.type,
+          data,
+          organizationId: getOrgId(data),
+          workspaceId: getWorkspaceId(data)
+        }, options, buildRbacMetadata(data));
+        if (entityDef.onUpdated) {
+          await entityDef.onUpdated(data, createEventContext(), options);
+        }
+      }, "updated"),
+      deleted: /* @__PURE__ */ __name(async (data, options) => {
+        await publisher.publishEntityDeleted({
+          id: data["id"],
+          type: entityDef.type,
+          data,
+          organizationId: getOrgId(data),
+          workspaceId: getWorkspaceId(data)
+        }, options, buildRbacMetadata(data));
+        if (entityDef.onDeleted) {
+          await entityDef.onDeleted(data, createEventContext(), options);
+        }
+      }, "deleted")
+    };
+  }
+  const getSchema = /* @__PURE__ */ __name(() => {
+    const entitySchema = {};
+    const relationshipSchema = {};
+    for (const [, entityDef] of Object.entries(entities)) {
+      entitySchema[entityDef.type] = {
+        fields: entityDef.fields || [
+          "id",
+          "createdAt",
+          "updatedAt"
+        ],
+        collection: entityDef.collection || "entity"
+      };
+    }
+    for (const [relName, relDef] of Object.entries(relationships)) {
+      relationshipSchema[relName] = {
+        fromType: relDef.fromType,
+        toType: relDef.toType,
+        edgeType: relDef.edgeType
+      };
+    }
+    return {
+      moduleName,
+      entities: entitySchema,
+      relationships: relationshipSchema
+    };
+  }, "getSchema");
+  const exportEntities = /* @__PURE__ */ __name(async (organizationId, workspaceId, entityTypes) => {
+    const result = {};
+    for (const [entityName, entityDef] of Object.entries(entities)) {
+      if (entityTypes && !entityTypes.includes(entityDef.type)) {
+        continue;
+      }
+      if (!entityDef.fetch) {
+        result[entityDef.type] = [];
+        continue;
+      }
+      try {
+        const items = await entityDef.fetch(organizationId, workspaceId);
+        result[entityDef.type] = items.map((item) => {
+          const { id, createdAt, updatedAt, workspaceId: ws, tenantId, ...data } = item;
+          return {
+            id,
+            type: entityDef.type,
+            data,
+            organizationId: tenantId,
+            workspaceId: ws,
+            createdAt: createdAt instanceof Date ? createdAt.toISOString() : String(createdAt),
+            updatedAt: updatedAt instanceof Date ? updatedAt.toISOString() : String(updatedAt)
+          };
+        });
+      } catch (error) {
+        logger.error(`[ModuleGraph:${moduleName}] Error fetching ${entityName}:`, error);
+        result[entityDef.type] = [];
+      }
+    }
+    return result;
+  }, "exportEntities");
+  const exportRelationships = /* @__PURE__ */ __name(async (organizationId, workspaceId) => {
+    const result = [];
+    for (const [relName, relDef] of Object.entries(relationships)) {
+      if (!relDef.fetch) {
+        continue;
+      }
+      try {
+        const items = await relDef.fetch(organizationId, workspaceId);
+        for (const item of items) {
+          result.push({
+            id: item.id,
+            type: relDef.edgeType,
+            fromId: item.fromId,
+            fromType: relDef.fromType,
+            toId: item.toId,
+            toType: relDef.toType,
+            metadata: item.metadata || {},
+            createdAt: item.createdAt || (/* @__PURE__ */ new Date()).toISOString(),
+            updatedAt: item.updatedAt || (/* @__PURE__ */ new Date()).toISOString()
+          });
+        }
+      } catch (error) {
+        logger.error(`[ModuleGraph:${moduleName}] Error fetching relationship ${relName}:`, error);
+      }
+    }
+    return result;
+  }, "exportRelationships");
+  const exportAll = /* @__PURE__ */ __name(async (organizationId, workspaceId) => {
+    const schema = getSchema();
+    const entitiesData = await exportEntities(organizationId, workspaceId);
+    const relationshipsData = await exportRelationships(organizationId, workspaceId);
+    const entityCounts = {};
+    let totalEntities = 0;
+    for (const [type, items] of Object.entries(entitiesData)) {
+      entityCounts[type] = items.length;
+      totalEntities += items.length;
+    }
+    return {
+      moduleName,
+      productSource: productSource ?? moduleName,
+      exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      schema,
+      data: {
+        entities: entitiesData,
+        relationships: relationshipsData
+      },
+      stats: {
+        totalEntities,
+        totalRelationships: relationshipsData.length,
+        entityCounts
+      }
+    };
+  }, "exportAll");
+  return {
+    moduleName,
+    events,
+    initialize: /* @__PURE__ */ __name(() => publisher.initialize(), "initialize"),
+    shutdown: /* @__PURE__ */ __name(() => publisher.shutdown(), "shutdown"),
+    getSchema,
+    exportEntities,
+    exportRelationships,
+    exportAll,
+    getPublisher: /* @__PURE__ */ __name(() => publisher, "getPublisher")
+  };
+}
+__name(defineModuleGraph, "defineModuleGraph");
+
+// src/graph/config/builder.ts
+var STANDARD_FIELDS = [
+  "id",
+  "createdAt",
+  "updatedAt"
+];
+var SOFT_DELETE_FIELDS = [
+  "deletedAt"
+];
+var AUDIT_FIELDS = [
+  "metadata",
+  "context"
+];
+var TENANT_FIELDS = [
+  "workspaceId",
+  "tenantId"
+];
+var DEFAULT_GET_WORKSPACE_ID = /* @__PURE__ */ __name((data) => data["workspaceId"], "DEFAULT_GET_WORKSPACE_ID");
+var DEFAULT_GET_ORG_ID = /* @__PURE__ */ __name((data) => {
+  if (data["tenantId"]) {
+    return data["tenantId"];
+  }
+  const context = data["context"];
+  return context?.["organizationId"];
+}, "DEFAULT_GET_ORG_ID");
+function createDefaultExtractTitle(entityType) {
+  return (data) => {
+    const id = data["id"];
+    if (typeof id === "string" && id.length > 0) {
+      return `${entityType.toLowerCase()}_${id}`;
+    }
+    return void 0;
+  };
+}
+__name(createDefaultExtractTitle, "createDefaultExtractTitle");
+function generateRelationshipLabel(relationshipName) {
+  return relationshipName.replace(/([A-Z])/g, "_$1").toUpperCase().replace(/^_/, "");
+}
+__name(generateRelationshipLabel, "generateRelationshipLabel");
+function extractFieldsFromModel(modelName, options, prismaFieldsModule) {
+  if (!prismaFieldsModule.hasModel(modelName)) {
+    const availableModels = prismaFieldsModule.getAllModelNames().join(", ");
+    throw new Error(`Prisma model '${modelName}' not found. Available models: ${availableModels}`);
+  }
+  const allFields = prismaFieldsModule.getScalarFields(modelName);
+  const sdkDefaults = [
+    ...STANDARD_FIELDS,
+    ...options.softDelete !== false ? SOFT_DELETE_FIELDS : [],
+    ...options.multiTenant !== false ? TENANT_FIELDS : [],
+    ...options.audit !== false ? AUDIT_FIELDS : []
+  ];
+  const excluded = /* @__PURE__ */ new Set([
+    ...sdkDefaults,
+    ...options.exclude ?? []
+  ]);
+  const filteredFields = allFields.filter((field) => !excluded.has(field));
+  const finalFields = [
+    ...filteredFields,
+    ...options.include ?? []
+  ];
+  return finalFields;
+}
+__name(extractFieldsFromModel, "extractFieldsFromModel");
+function validateEntityConfig(entityType, config) {
+  const errors = [];
+  if (!config.fields || config.fields.length === 0) {
+    errors.push({
+      type: "INVALID_ENTITY_TYPE",
+      entityType,
+      message: `Entity '${entityType}' must have at least one field`
+    });
+  }
+  if (!config.getWorkspaceId) {
+    errors.push({
+      type: "MISSING_WORKSPACE_ID",
+      entityType,
+      message: `Entity '${entityType}' must define getWorkspaceId() to enforce workspace boundary`
+    });
+  }
+  if (!config.getOrgId) {
+    errors.push({
+      type: "MISSING_ORG_ID",
+      entityType,
+      message: `Entity '${entityType}' must define getOrgId() for multi-tenant isolation`
+    });
+  }
+  return errors;
+}
+__name(validateEntityConfig, "validateEntityConfig");
+function validateRelationshipConfig(relationshipKey, config, entityTypes) {
+  const errors = [];
+  if (!entityTypes.has(config.from)) {
+    errors.push({
+      type: "INVALID_RELATIONSHIP",
+      relationshipKey,
+      message: `Relationship '${relationshipKey}' references unknown 'from' entity: ${config.from}`
+    });
+  }
+  if (config.to !== "*" && !entityTypes.has(config.to)) {
+    errors.push({
+      type: "INVALID_RELATIONSHIP",
+      relationshipKey,
+      message: `Relationship '${relationshipKey}' references unknown 'to' entity: ${config.to}`
+    });
+  }
+  if (config.to === "*" && !config.polymorphicTypeField) {
+    errors.push({
+      type: "INVALID_RELATIONSHIP",
+      relationshipKey,
+      message: `Polymorphic relationship '${relationshipKey}' must define polymorphicTypeField`
+    });
+  }
+  if (!config.fromField) {
+    errors.push({
+      type: "INVALID_RELATIONSHIP",
+      relationshipKey,
+      message: `Relationship '${relationshipKey}' must define fromField`
+    });
+  }
+  if (!config.label) {
+    errors.push({
+      type: "INVALID_RELATIONSHIP",
+      relationshipKey,
+      message: `Relationship '${relationshipKey}' must define label`
+    });
+  }
+  return errors;
+}
+__name(validateRelationshipConfig, "validateRelationshipConfig");
+function validateWorkspaceBoundary(config, _entityTypes) {
+  const errors = [];
+  const warnings = [];
+  const rootTypes = /* @__PURE__ */ new Set([
+    "Workspace",
+    "Project",
+    "Organization",
+    "Tenant"
+  ]);
+  for (const [entityType, entityConfig] of Object.entries(config.entities)) {
+    if (entityConfig.enabled === false) continue;
+    if (rootTypes.has(entityType)) {
+      continue;
+    }
+    if (!entityConfig.getWorkspaceId) {
+      errors.push({
+        type: "ORPHANED_ENTITY",
+        entityType,
+        message: `Entity '${entityType}' has no workspace boundary - every entity must connect to a workspace`
+      });
+      continue;
+    }
+    let hasWorkspaceLink = false;
+    if (config.relationships) {
+      for (const [, relConfig] of Object.entries(config.relationships)) {
+        if (relConfig.enabled === false) continue;
+        if (relConfig.from === entityType && (relConfig.to === "Workspace" || relConfig.to === "Project" || rootTypes.has(relConfig.to))) {
+          hasWorkspaceLink = true;
+          break;
+        }
+      }
+    }
+    if (!hasWorkspaceLink) {
+      warnings.push(`Entity '${entityType}' has no direct relationship to Workspace/Project. Ensure getWorkspaceId() is correctly implemented.`);
+    }
+  }
+  return {
+    errors,
+    warnings
+  };
+}
+__name(validateWorkspaceBoundary, "validateWorkspaceBoundary");
+function validateNoDuplicates(config, _entityTypes) {
+  const errors = [];
+  const warnings = [];
+  const seenEntityTypes = /* @__PURE__ */ new Set();
+  const relationshipLabels = /* @__PURE__ */ new Set();
+  for (const entityType of Object.keys(config.entities)) {
+    if (seenEntityTypes.has(entityType)) {
+      errors.push({
+        type: "DUPLICATE_ENTITY_TYPE",
+        entityType,
+        message: `Duplicate entity type: ${entityType}`
+      });
+    }
+    seenEntityTypes.add(entityType);
+  }
+  if (config.relationships) {
+    for (const [key, relConfig] of Object.entries(config.relationships)) {
+      const label = relConfig.label;
+      if (relationshipLabels.has(label)) {
+        warnings.push(`Duplicate relationship label: ${label} (in ${key}). This may cause query ambiguity.`);
+      }
+      relationshipLabels.add(label);
+    }
+  }
+  return {
+    errors,
+    warnings
+  };
+}
+__name(validateNoDuplicates, "validateNoDuplicates");
+function validateGraphConfig(config) {
+  const allErrors = [];
+  const allWarnings = [];
+  for (const [entityType, entityConfig] of Object.entries(config.entities)) {
+    if (entityConfig.enabled === false) continue;
+    const errors = validateEntityConfig(entityType, entityConfig);
+    allErrors.push(...errors);
+  }
+  const entityTypes = new Set(Object.keys(config.entities));
+  if (config.relationships) {
+    for (const [relationshipKey, relationshipConfig] of Object.entries(config.relationships)) {
+      if (relationshipConfig.enabled === false) continue;
+      const errors = validateRelationshipConfig(relationshipKey, relationshipConfig, entityTypes);
+      allErrors.push(...errors);
+    }
+  }
+  const boundaryResult = validateWorkspaceBoundary(config);
+  allErrors.push(...boundaryResult.errors);
+  allWarnings.push(...boundaryResult.warnings);
+  const duplicateResult = validateNoDuplicates(config);
+  allErrors.push(...duplicateResult.errors);
+  allWarnings.push(...duplicateResult.warnings);
+  return {
+    valid: allErrors.length === 0,
+    errors: allErrors,
+    warnings: allWarnings
+  };
+}
+__name(validateGraphConfig, "validateGraphConfig");
+function processEntityConfig(entityName, entityOptions, prismaFieldsModule) {
+  const { softDelete = true, multiTenant = true, audit = true, fields, model, exclude, include, collection, getWorkspaceId, getOrgId, extractTitle, rbac, ...rest } = entityOptions;
+  let entityFields;
+  if (model) {
+    if (!prismaFieldsModule) {
+      throw new Error(`Entity '${entityName}' uses model='${model}' but prismaFieldsModule is not provided. Import prisma-fields.ts and pass it to defineGraphConfig({ prismaFieldsModule: ... })`);
+    }
+    entityFields = extractFieldsFromModel(model, {
+      exclude,
+      include,
+      softDelete,
+      multiTenant,
+      audit
+    }, prismaFieldsModule);
+  } else if (fields) {
+    entityFields = fields;
+  } else {
+    throw new Error(`Entity '${entityName}' must specify either 'fields' or 'model' for field definition`);
+  }
+  const autoFields = [
+    ...STANDARD_FIELDS,
+    ...softDelete ? SOFT_DELETE_FIELDS : [],
+    ...multiTenant ? TENANT_FIELDS : [],
+    ...audit ? AUDIT_FIELDS : []
+  ];
+  const mergedFields = [
+    .../* @__PURE__ */ new Set([
+      ...autoFields,
+      ...entityFields
+    ])
+  ];
+  const finalGetWorkspaceId = multiTenant === false ? (_data) => void 0 : getWorkspaceId ?? DEFAULT_GET_WORKSPACE_ID;
+  const finalGetOrgId = multiTenant === false ? (_data) => void 0 : getOrgId ?? DEFAULT_GET_ORG_ID;
+  return {
+    collection: collection ?? "entities",
+    fields: mergedFields,
+    getWorkspaceId: finalGetWorkspaceId,
+    getOrgId: finalGetOrgId,
+    extractTitle: extractTitle ?? createDefaultExtractTitle(entityName),
+    ...rbac && {
+      rbac
+    },
+    ...rest
+  };
+}
+__name(processEntityConfig, "processEntityConfig");
+function processRelationships(relationshipOptions) {
+  const relationships = {};
+  for (const [relationshipName, options] of Object.entries(relationshipOptions)) {
+    const { label, toField, ...rest } = options;
+    relationships[relationshipName] = {
+      toField: toField ?? "id",
+      label: label ?? generateRelationshipLabel(relationshipName),
+      ...rest
+    };
+  }
+  return relationships;
+}
+__name(processRelationships, "processRelationships");
+function logValidationResults(moduleName, validationResult) {
+  if (validationResult.errors.length > 0) {
+    logger.error(`[GraphConfig:${moduleName}] Configuration validation failed:`);
+    for (const error of validationResult.errors) {
+      logger.error(`  - ${error.message}`, {
+        type: error.type,
+        entityType: error.entityType,
+        relationshipKey: error.relationshipKey
+      });
+    }
+    throw new Error(`Graph configuration validation failed for ${moduleName}`);
+  }
+  if (validationResult.warnings.length > 0) {
+    logger.warn(`[GraphConfig:${moduleName}] Configuration warnings:`);
+    for (const warning of validationResult.warnings) {
+      logger.warn(`  - ${warning}`);
+    }
+  }
+  logger.info(`[GraphConfig:${moduleName}] Configuration validated successfully`, {
+    valid: validationResult.valid,
+    errorCount: validationResult.errors.length,
+    warningCount: validationResult.warnings.length,
+    autoFieldsApplied: true
+  });
+}
+__name(logValidationResults, "logValidationResults");
+function defineGraphConfig(options) {
+  const entities = {};
+  for (const [entityName, entityOptions] of Object.entries(options.entities)) {
+    entities[entityName] = processEntityConfig(entityName, entityOptions, options.prismaFieldsModule);
+  }
+  const relationships = options.relationships ? processRelationships(options.relationships) : {};
+  const config = {
+    moduleName: options.moduleName,
+    entities,
+    relationships
+  };
+  const validationResult = validateGraphConfig(config);
+  logValidationResults(config.moduleName, validationResult);
+  autoRegisterWithRegistry(config);
+  return config;
+}
+__name(defineGraphConfig, "defineGraphConfig");
+function autoRegisterWithRegistry(config) {
+  const { moduleName, entities, relationships = {} } = config;
+  const registryEntities = {};
+  for (const [entityType, entityConfig] of Object.entries(entities)) {
+    registryEntities[entityType] = {
+      fields: entityConfig.fields,
+      collection: entityConfig.collection || "entities",
+      extractTitle: entityConfig.extractTitle,
+      getOrgId: entityConfig.getOrgId,
+      getWorkspaceId: entityConfig.getWorkspaceId,
+      enabled: entityConfig.enabled,
+      // Pass through RBAC config so the Prisma graph extension
+      // can include RBAC metadata in entity lifecycle events
+      ...entityConfig.rbac && {
+        rbac: {
+          resourceTypeName: entityConfig.rbac.resourceTypeName,
+          extractName: entityConfig.rbac.extractName,
+          extractIdentifier: entityConfig.rbac.extractIdentifier,
+          parentResourceField: entityConfig.rbac.parentResourceField,
+          createResource: entityConfig.rbac.createResource
+        }
+      }
+    };
+  }
+  const registryRelationships = {};
+  for (const [key, relConfig] of Object.entries(relationships)) {
+    registryRelationships[key] = {
+      from: relConfig.from,
+      to: relConfig.to,
+      fromField: relConfig.fromField,
+      toField: relConfig.toField,
+      label: relConfig.label,
+      description: relConfig.description,
+      extractMetadata: relConfig.extractMetadata,
+      polymorphicTypeField: relConfig.polymorphicTypeField,
+      enabled: relConfig.enabled
+    };
+  }
+  GraphRegistry.registerModule({
+    moduleName,
+    entities: registryEntities,
+    relationships: registryRelationships
+  });
+  logger.info(`[GraphConfig:${moduleName}] Auto-registered ${Object.keys(entities).length} entities with GraphRegistry`);
+}
+__name(autoRegisterWithRegistry, "autoRegisterWithRegistry");
+function defineEntity(config) {
+  return config;
+}
+__name(defineEntity, "defineEntity");
+function defineRelationship(config) {
+  return config;
+}
+__name(defineRelationship, "defineRelationship");
+
+// src/graph/config/init.ts
+var RuntimeValidator = class RuntimeValidator2 {
+  static {
+    __name(this, "RuntimeValidator");
+  }
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+  * Validate entity data extraction
+  */
+  validateEntityData(entityType, data) {
+    const errors = [];
+    const entityConfig = this.config.entities[entityType];
+    if (!entityConfig) {
+      return {
+        valid: true,
+        errors: []
+      };
+    }
+    try {
+      const workspaceId = entityConfig.getWorkspaceId(data);
+      if (!workspaceId) {
+        errors.push(`Entity ${entityType}:${data["id"]} has no workspaceId`);
+      }
+    } catch (error) {
+      errors.push(`Error extracting workspaceId for ${entityType}: ${error}`);
+    }
+    try {
+      const orgId = entityConfig.getOrgId(data);
+      if (!orgId) {
+        errors.push(`Entity ${entityType}:${data["id"]} has no organizationId`);
+      }
+    } catch (error) {
+      errors.push(`Error extracting organizationId for ${entityType}: ${error}`);
+    }
+    for (const field of entityConfig.fields) {
+      if (!(field in data)) {
+        errors.push(`Entity ${entityType}:${data["id"]} missing configured field: ${field}`);
+      }
+    }
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+};
+function initializeGraph(prismaClient, config, options) {
+  const { productName, eventEmitter, monitoredEntityTypes = [], enabled = true, validateRuntime } = options;
+  const shouldValidate = validateRuntime ?? process.env["NODE_ENV"] !== "production";
+  logger.info(`[GraphInit:${config.moduleName}] Initializing graph integration`, {
+    productName,
+    enabled,
+    validateRuntime: shouldValidate,
+    entities: Object.keys(config.entities).length,
+    relationships: config.relationships ? Object.keys(config.relationships).length : 0
+  });
+  if (!enabled) {
+    logger.warn(`[GraphInit:${config.moduleName}] Graph integration disabled by configuration`);
+    return prismaClient;
+  }
+  registerConfigWithRegistry(config);
+  const validator = shouldValidate ? new RuntimeValidator(config) : null;
+  const wrappedEmitter = {
+    publishEntityEvent: /* @__PURE__ */ __name(async (eventType, entity, context, rbac) => {
+      if (validator && (eventType === "entity.created" || eventType === "entity.updated")) {
+        const validation = validator.validateEntityData(entity.type, entity.data);
+        if (!validation.valid) {
+          logger.error(`[GraphInit:${config.moduleName}] Runtime validation failed for ${entity.type}:${entity.id}`, {
+            errors: validation.errors
+          });
+        }
+      }
+      return eventEmitter.publishEntityEvent(eventType, entity, context, rbac);
+    }, "publishEntityEvent")
+  };
+  const extendedClient = addGraphExtension(prismaClient, {
+    enabled: true,
+    productName,
+    eventEmitter: wrappedEmitter,
+    entityTypes: monitoredEntityTypes
+  });
+  logger.info(`[GraphInit:${config.moduleName}] Graph integration initialized successfully`);
+  return extendedClient;
+}
+__name(initializeGraph, "initializeGraph");
+function registerConfigWithRegistry(config) {
+  const { moduleName, entities, relationships = {} } = config;
+  const registryEntities = {};
+  for (const [entityType, entityConfig] of Object.entries(entities)) {
+    registryEntities[entityType] = {
+      fields: entityConfig.fields,
+      collection: entityConfig.collection || "entities",
+      extractTitle: entityConfig.extractTitle,
+      getOrgId: entityConfig.getOrgId,
+      getWorkspaceId: entityConfig.getWorkspaceId,
+      enabled: entityConfig.enabled
+    };
+  }
+  const registryRelationships = {};
+  for (const [key, relConfig] of Object.entries(relationships)) {
+    registryRelationships[key] = {
+      from: relConfig.from,
+      to: relConfig.to,
+      fromField: relConfig.fromField,
+      toField: relConfig.toField,
+      label: relConfig.label,
+      description: relConfig.description,
+      extractMetadata: relConfig.extractMetadata,
+      polymorphicTypeField: relConfig.polymorphicTypeField,
+      enabled: relConfig.enabled
+    };
+  }
+  GraphRegistry.registerModule({
+    moduleName,
+    entities: registryEntities,
+    relationships: registryRelationships
+  });
+  logger.info(`[GraphInit:${moduleName}] Configuration registered with GraphRegistry`);
+}
+__name(registerConfigWithRegistry, "registerConfigWithRegistry");
+function isGraphInitialized(moduleName) {
+  const registeredModules = GraphRegistry.getRegisteredModules();
+  return registeredModules.includes(moduleName);
+}
+__name(isGraphInitialized, "isGraphInitialized");
+function getGraphStats() {
+  const stats = GraphRegistry.getStats();
+  const registeredModules = GraphRegistry.getRegisteredModules();
+  return {
+    modules: stats.modules,
+    entities: stats.entities,
+    relationships: stats.relationships,
+    registeredModules
+  };
+}
+__name(getGraphStats, "getGraphStats");
+
+// src/graph/index.ts
+var GraphModule = class {
+  static {
+    __name(this, "GraphModule");
+  }
+  client;
+  context;
+  constructor(client, context) {
+    this.client = client;
+    this.context = context;
+  }
+  /**
+  * Create graph node
+  */
+  async createNode(options) {
+    if (!options.type) {
+      throw new ValidationError("Node type is required");
+    }
+    if (!options.properties || typeof options.properties !== "object") {
+      throw new ValidationError("Node properties must be an object");
+    }
+    logger.debug("[Graph] Creating node", {
+      type: options.type
+    });
+    const mutation = `
+      mutation CreateGraphNode($input: CreateGraphNodeInput!) {
+        createGraphNode(input: $input) {
+          id
+          type
+          properties
+          workspaceId
+          organizationId
+          createdAt
+          updatedAt
+        }
+      }
+    `;
+    const variables = {
+      input: {
+        type: options.type,
+        properties: options.properties,
+        workspaceId: options.workspaceId || this.context.workspaceId,
+        organizationId: options.organizationId
+      }
+    };
+    const response = await this.client.query(mutation, variables, this.context);
+    logger.info("[Graph] Node created", {
+      nodeId: response.createGraphNode.id
+    });
+    return response.createGraphNode;
+  }
+  /**
+  * Create graph edge
+  */
+  async createEdge(options) {
+    if (!options.from) {
+      throw new ValidationError("Source node ID is required");
+    }
+    if (!options.to) {
+      throw new ValidationError("Target node ID is required");
+    }
+    if (!options.type) {
+      throw new ValidationError("Edge type is required");
+    }
+    logger.debug("[Graph] Creating edge", {
+      from: options.from,
+      to: options.to,
+      type: options.type
+    });
+    const mutation = `
+      mutation CreateGraphEdge($input: CreateGraphEdgeInput!) {
+        createGraphEdge(input: $input) {
+          id
+          from
+          to
+          type
+          properties
+          workspaceId
+          organizationId
+          createdAt
+        }
+      }
+    `;
+    const variables = {
+      input: {
+        from: options.from,
+        to: options.to,
+        type: options.type,
+        properties: options.properties,
+        workspaceId: options.workspaceId || this.context.workspaceId,
+        organizationId: options.organizationId
+      }
+    };
+    const response = await this.client.query(mutation, variables, this.context);
+    logger.info("[Graph] Edge created", {
+      edgeId: response.createGraphEdge.id
+    });
+    return response.createGraphEdge;
+  }
+  /**
+  * Get node by ID
+  */
+  async getNode(nodeId) {
+    logger.debug("[Graph] Getting node", {
+      nodeId
+    });
+    const query = `
+      query GetGraphNode($nodeId: ID!) {
+        getGraphNode(nodeId: $nodeId) {
+          id
+          type
+          properties
+          workspaceId
+          organizationId
+          createdAt
+          updatedAt
+        }
+      }
+    `;
+    const response = await this.client.query(query, {
+      nodeId
+    }, this.context);
+    return response.getGraphNode;
+  }
+  /**
+  * Update node
+  */
+  async updateNode(nodeId, properties) {
+    logger.debug("[Graph] Updating node", {
+      nodeId
+    });
+    const mutation = `
+      mutation UpdateGraphNode($nodeId: ID!, $properties: JSON!) {
+        updateGraphNode(nodeId: $nodeId, properties: $properties) {
+          id
+          type
+          properties
+          workspaceId
+          organizationId
+          createdAt
+          updatedAt
+        }
+      }
+    `;
+    const response = await this.client.query(mutation, {
+      nodeId,
+      properties
+    }, this.context);
+    logger.info("[Graph] Node updated", {
+      nodeId
+    });
+    return response.updateGraphNode;
+  }
+  /**
+  * Delete node
+  */
+  async deleteNode(nodeId) {
+    logger.debug("[Graph] Deleting node", {
+      nodeId
+    });
+    const mutation = `
+      mutation DeleteGraphNode($nodeId: ID!) {
+        deleteGraphNode(nodeId: $nodeId) {
+          success
+        }
+      }
+    `;
+    await this.client.query(mutation, {
+      nodeId
+    }, this.context);
+    logger.info("[Graph] Node deleted", {
+      nodeId
+    });
+    return true;
+  }
+  /**
+  * Delete edge
+  */
+  async deleteEdge(edgeId) {
+    logger.debug("[Graph] Deleting edge", {
+      edgeId
+    });
+    const mutation = `
+      mutation DeleteGraphEdge($edgeId: ID!) {
+        deleteGraphEdge(edgeId: $edgeId) {
+          success
+        }
+      }
+    `;
+    await this.client.query(mutation, {
+      edgeId
+    }, this.context);
+    logger.info("[Graph] Edge deleted", {
+      edgeId
+    });
+    return true;
+  }
+  /**
+  * Traverse graph
+  */
+  async traverse(options) {
+    if (!options.startNode) {
+      throw new ValidationError("Start node ID is required");
+    }
+    logger.debug("[Graph] Traversing graph", {
+      startNode: options.startNode,
+      direction: options.direction || "outbound"
+    });
+    const query = `
+      query TraverseGraph(
+        $startNode: ID!
+        $direction: GraphDirection
+        $edgeTypes: [String!]
+        $minDepth: Int
+        $maxDepth: Int
+        $limit: Int
+      ) {
+        traverseGraph(
+          startNode: $startNode
+          direction: $direction
+          edgeTypes: $edgeTypes
+          minDepth: $minDepth
+          maxDepth: $maxDepth
+          limit: $limit
+        ) {
+          nodes {
+            id
+            type
+            properties
+            workspaceId
+            organizationId
+            createdAt
+            updatedAt
+          }
+          edges {
+            id
+            from
+            to
+            type
+            properties
+            workspaceId
+            organizationId
+            createdAt
+          }
+          paths {
+            nodes {
+              id
+              type
+              properties
+            }
+            edges {
+              id
+              from
+              to
+              type
+            }
+          }
+        }
+      }
+    `;
+    const variables = {
+      startNode: options.startNode,
+      direction: options.direction || "outbound",
+      edgeTypes: options.edgeTypes,
+      minDepth: options.minDepth || 1,
+      maxDepth: options.maxDepth || 3,
+      limit: options.limit || 100
+    };
+    const response = await this.client.query(query, variables, this.context);
+    return response.traverseGraph;
+  }
+  /**
+  * Find shortest path between two nodes
+  */
+  async findShortestPath(fromNode, toNode, options) {
+    logger.debug("[Graph] Finding shortest path", {
+      fromNode,
+      toNode
+    });
+    const query = `
+      query FindShortestPath(
+        $fromNode: ID!
+        $toNode: ID!
+        $edgeTypes: [String!]
+        $maxDepth: Int
+      ) {
+        findShortestPath(
+          fromNode: $fromNode
+          toNode: $toNode
+          edgeTypes: $edgeTypes
+          maxDepth: $maxDepth
+        ) {
+          nodes {
+            id
+            type
+            properties
+          }
+          edges {
+            id
+            from
+            to
+            type
+          }
+          distance
+        }
+      }
+    `;
+    const response = await this.client.query(query, {
+      fromNode,
+      toNode,
+      edgeTypes: options?.edgeTypes,
+      maxDepth: options?.maxDepth || 10
+    }, this.context);
+    return response.findShortestPath;
+  }
+  /**
+  * Query graph with nGQL. Proxied to wspace-graph-svc's `executeNGQL` resolver
+  * via the federated GraphQL gateway — no direct graph-DB access.
+  */
+  async query(options) {
+    if (!options.query) {
+      throw new ValidationError("nGQL query is required");
+    }
+    logger.debug("[Graph] Executing nGQL query");
+    const query = `
+      query ExecuteNGQL($query: String!, $bindVars: JSON, $limit: Int) {
+        executeNGQL(query: $query, bindVars: $bindVars, limit: $limit) {
+          results
+        }
+      }
+    `;
+    const variables = {
+      query: options.query,
+      bindVars: options.bindVars,
+      limit: options.limit || 1e3
+    };
+    const response = await this.client.query(query, variables, this.context);
+    return response.executeNGQL.results;
+  }
+  /**
+  * Get neighbors of a node
+  */
+  async getNeighbors(nodeId, options) {
+    logger.debug("[Graph] Getting neighbors", {
+      nodeId
+    });
+    const query = `
+      query GetNeighbors(
+        $nodeId: ID!
+        $direction: GraphDirection
+        $edgeTypes: [String!]
+        $limit: Int
+      ) {
+        getNeighbors(
+          nodeId: $nodeId
+          direction: $direction
+          edgeTypes: $edgeTypes
+          limit: $limit
+        ) {
+          nodes {
+            id
+            type
+            properties
+            workspaceId
+            organizationId
+            createdAt
+            updatedAt
+          }
+          edges {
+            id
+            from
+            to
+            type
+            properties
+            workspaceId
+            organizationId
+            createdAt
+          }
+        }
+      }
+    `;
+    const response = await this.client.query(query, {
+      nodeId,
+      direction: options?.direction || "outbound",
+      edgeTypes: options?.edgeTypes,
+      limit: options?.limit || 100
+    }, this.context);
+    return response.getNeighbors;
+  }
+  /**
+  * Get node degree (number of connections)
+  */
+  async getNodeDegree(nodeId, direction) {
+    logger.debug("[Graph] Getting node degree", {
+      nodeId
+    });
+    const query = `
+      query GetNodeDegree($nodeId: ID!, $direction: GraphDirection) {
+        getNodeDegree(nodeId: $nodeId, direction: $direction) {
+          inbound
+          outbound
+          total
+        }
+      }
+    `;
+    const response = await this.client.query(query, {
+      nodeId,
+      direction
+    }, this.context);
+    return response.getNodeDegree;
+  }
+  /**
+  * Find nodes by properties
+  */
+  async findNodes(type, filters, options) {
+    logger.debug("[Graph] Finding nodes", {
+      type,
+      filters
+    });
+    const query = `
+      query FindGraphNodes(
+        $type: String!
+        $filters: JSON!
+        $limit: Int
+        $offset: Int
+      ) {
+        findGraphNodes(
+          type: $type
+          filters: $filters
+          limit: $limit
+          offset: $offset
+        ) {
+          nodes {
+            id
+            type
+            properties
+            workspaceId
+            organizationId
+            createdAt
+            updatedAt
+          }
+          total
+        }
+      }
+    `;
+    const response = await this.client.query(query, {
+      type,
+      filters,
+      limit: options?.limit || 100,
+      offset: options?.offset || 0
+    }, this.context);
+    return response.findGraphNodes;
+  }
+  /**
+  * Batch create nodes
+  */
+  async createNodesBatch(nodes) {
+    logger.debug("[Graph] Batch creating nodes", {
+      count: nodes.length
+    });
+    const mutation = `
+      mutation CreateGraphNodesBatch($nodes: [CreateGraphNodeInput!]!) {
+        createGraphNodesBatch(nodes: $nodes) {
+          id
+          type
+          properties
+          workspaceId
+          organizationId
+          createdAt
+          updatedAt
+        }
+      }
+    `;
+    const response = await this.client.query(mutation, {
+      nodes
+    }, this.context);
+    logger.info("[Graph] Nodes batch created", {
+      count: response.createGraphNodesBatch.length
+    });
+    return response.createGraphNodesBatch;
+  }
+  /**
+  * Batch create edges
+  */
+  async createEdgesBatch(edges) {
+    logger.debug("[Graph] Batch creating edges", {
+      count: edges.length
+    });
+    const mutation = `
+      mutation CreateGraphEdgesBatch($edges: [CreateGraphEdgeInput!]!) {
+        createGraphEdgesBatch(edges: $edges) {
+          id
+          from
+          to
+          type
+          properties
+          workspaceId
+          organizationId
+          createdAt
+        }
+      }
+    `;
+    const response = await this.client.query(mutation, {
+      edges
+    }, this.context);
+    logger.info("[Graph] Edges batch created", {
+      count: response.createGraphEdgesBatch.length
+    });
+    return response.createGraphEdgesBatch;
+  }
+};
+
+export { AUDIT_FIELDS, GraphEventsPublisher, GraphExportService, GraphModule, SOFT_DELETE_FIELDS, STANDARD_FIELDS, TENANT_FIELDS, createGraphEventsHelper, createGraphExportService, createPrismaGraphIntegration, createRelationshipFromEntity, defineEntity, defineGraphConfig, defineModuleGraph, defineRelationship, getGraphEventsPublisher, getGraphStats, graph_exports, initializeGraph, isGraphInitialized };
+//# sourceMappingURL=chunk-F5XEAGHQ.js.map
+//# sourceMappingURL=chunk-F5XEAGHQ.js.map