@decaf-ts/integrations 0.3.6 → 0.3.8

package/lib/cjs/namespaces/utils.cjs

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transactional = exports.AuthorizationError = exports.BaseModelService = exports.REL_CASCADE_INSERT_UPDATE = exports.REL_CASCADE_DEPENDENT = exports.REL_NULLIFY = exports.REL_RESTRICT = void 0;
+exports.buildArangoContext = buildArangoContext;
+exports.buildQdrantFilter = buildQdrantFilter;
+exports.nowIso = nowIso;
+exports.asArray = asArray;
+exports.sameTenant = sameTenant;
+exports.relationMatch = relationMatch;
+exports.lowerSlug = lowerSlug;
+exports.isTimeValid = isTimeValid;
+exports.buildAccessContext = buildAccessContext;
+exports.id = id;
+exports.relationId = relationId;
+const core_1 = require("@decaf-ts/core");
+const types_js_1 = require("./types.cjs");
+exports.REL_RESTRICT = {
+    update: core_1.Cascade.NONE,
+    delete: core_1.Cascade.NONE,
+    nullable: false,
+};
+exports.REL_NULLIFY = {
+    update: core_1.Cascade.NONE,
+    delete: core_1.Cascade.NONE,
+    nullable: true,
+};
+exports.REL_CASCADE_DEPENDENT = {
+    update: core_1.Cascade.CASCADE,
+    delete: core_1.Cascade.CASCADE,
+    nullable: false,
+};
+exports.REL_CASCADE_INSERT_UPDATE = {
+    update: core_1.Cascade.CASCADE,
+    delete: core_1.Cascade.NONE,
+    nullable: false,
+};
+function buildArangoContext(options) {
+    return {
+        tenantId: options.tenantId,
+        principalId: options.principalId,
+        permissionKey: options.permissionKey,
+        allowedOrgUnitIds: [...options.allowedOrgUnitIds],
+        allowedResourceIds: [...options.allowedResourceIds],
+    };
+}
+function buildQdrantFilter(options) {
+    return {
+        must: [
+            {
+                key: "tenant_id",
+                match: { value: options.tenantId },
+            },
+            {
+                should: [
+                    { key: "org_unit_id", match: { any: options.allowedOrgUnitIds } },
+                    { key: "protected_resource_id", match: { any: options.allowedResourceIds } },
+                    { key: "owner_principal_id", match: { value: options.principalId } },
+                ],
+            },
+        ],
+    };
+}
+function scopeKey(scopeKind, scopeId) {
+    return `${scopeKind}:${scopeId}`;
+}
+function nowIso() {
+    return new Date();
+}
+function asArray(value) {
+    return value ?? [];
+}
+function sameTenant(rowTenant, tenantId) {
+    return relationId(rowTenant) === tenantId;
+}
+function relationMatch(value, target) {
+    return target ? relationId(value) === target : false;
+}
+function lowerSlug(value) {
+    return (value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "") || "item");
+}
+function isTimeValid(at, startsAt, expiresAt) {
+    const instant = at ?? new Date();
+    if (startsAt && instant < startsAt)
+        return false;
+    if (expiresAt && instant > expiresAt)
+        return false;
+    return true;
+}
+function buildAccessContext(options) {
+    const permissionsByScope = {};
+    const allowedOrgUnitIdsByPermission = {};
+    for (const permission of options.permissions) {
+        const key = scopeKey(permission.scopeKind, permission.scopeId);
+        permissionsByScope[key] = permissionsByScope[key] ?? [];
+        permissionsByScope[key].push(permission.permissionKey);
+        if (permission.scopeKind === types_js_1.ScopeKind.OrgUnit) {
+            allowedOrgUnitIdsByPermission[permission.permissionKey] =
+                allowedOrgUnitIdsByPermission[permission.permissionKey] ?? [];
+            allowedOrgUnitIdsByPermission[permission.permissionKey].push(permission.scopeId);
+        }
+    }
+    return {
+        tenantId: options.tenantId,
+        principalId: options.principalId,
+        permissionsByScope,
+        allowedOrgUnitIdsByPermission,
+        resourceGrants: options.grants.map((grant) => ({
+            resourceId: grant.resourceId,
+            permissionKey: grant.permissionKey,
+        })),
+    };
+}
+class BaseModelService extends core_1.ModelService {
+    constructor(clazz) {
+        super(clazz);
+    }
+    newModel(clazz, data) {
+        return Object.assign(new clazz(), data);
+    }
+    async create(data, ...args) {
+        return this.repo.create(Object.assign({}, data), ...args);
+    }
+    async createOne(data, ...args) {
+        return this.create(data, ...args);
+    }
+    async getById(id, ...args) {
+        return this.repo.read(id, ...args);
+    }
+    async updateOne(id, patch, ...args) {
+        const existing = await this.repo.read(id, ...args);
+        return this.repo.update(Object.assign(existing, patch), ...args);
+    }
+    async deleteById(id, ...args) {
+        await this.repo.delete(id, ...args);
+    }
+    async findOneBy(key, value, ...args) {
+        return this.repo.findOneBy(key, value, ...args);
+    }
+    async findManyBy(key, value, ...args) {
+        return this.repo.select().where({ [key]: value }).execute(...args);
+    }
+    async listAll(...args) {
+        return this.repo.select().execute(...args);
+    }
+}
+exports.BaseModelService = BaseModelService;
+function id() {
+    return crypto.randomUUID();
+}
+function relationId(value) {
+    return typeof value === "string" ? value : value.id;
+}
+var core_2 = require("@decaf-ts/core");
+Object.defineProperty(exports, "AuthorizationError", { enumerable: true, get: function () { return core_2.AuthorizationError; } });
+Object.defineProperty(exports, "transactional", { enumerable: true, get: function () { return core_2.transactional; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../src/namespaces/utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { AuthorizationError, Cascade, ModelService, Repository } from \"@decaf-ts/core\";\nimport { Model } from \"@decaf-ts/decorator-validation\";\nimport {\n  AccessContext,\n  ArangoAuthContext,\n  EffectivePermissionSnapshot,\n  GrantSnapshot,\n  QdrantAuthFilter,\n  ResourceVisibility,\n  ScopeKind,\n} from \"./types\";\n\nexport const REL_RESTRICT = {\n  update: Cascade.NONE,\n  delete: Cascade.NONE,\n  nullable: false,\n} as const;\n\nexport const REL_NULLIFY = {\n  update: Cascade.NONE,\n  delete: Cascade.NONE,\n  nullable: true,\n} as const;\n\nexport const REL_CASCADE_DEPENDENT = {\n  update: Cascade.CASCADE,\n  delete: Cascade.CASCADE,\n  nullable: false,\n} as const;\n\nexport const REL_CASCADE_INSERT_UPDATE = {\n  update: Cascade.CASCADE,\n  delete: Cascade.NONE,\n  nullable: false,\n} as const;\n\nexport function buildArangoContext(options: {\n  tenantId: string;\n  principalId: string;\n  permissionKey: string;\n  allowedOrgUnitIds: string[];\n  allowedResourceIds: string[];\n}): ArangoAuthContext {\n  return {\n    tenantId: options.tenantId,\n    principalId: options.principalId,\n    permissionKey: options.permissionKey,\n    allowedOrgUnitIds: [...options.allowedOrgUnitIds],\n    allowedResourceIds: [...options.allowedResourceIds],\n  };\n}\n\nexport function buildQdrantFilter(options: {\n  tenantId: string;\n  principalId: string;\n  permissionKey: string;\n  allowedOrgUnitIds: string[];\n  allowedResourceIds: string[];\n}): QdrantAuthFilter {\n  return {\n    must: [\n      {\n        key: \"tenant_id\",\n        match: { value: options.tenantId },\n      },\n      {\n        should: [\n          { key: \"org_unit_id\", match: { any: options.allowedOrgUnitIds } },\n          { key: \"protected_resource_id\", match: { any: options.allowedResourceIds } },\n          { key: \"owner_principal_id\", match: { value: options.principalId } },\n        ],\n      },\n    ],\n  };\n}\n\nfunction scopeKey(scopeKind: ScopeKind, scopeId: string): string {\n  return `${scopeKind}:${scopeId}`;\n}\n\nexport function nowIso(): Date {\n  return new Date();\n}\n\nexport function asArray<T>(value: T[] | undefined): T[] {\n  return value ?? [];\n}\n\nexport function sameTenant(rowTenant: unknown, tenantId: string): boolean {\n  return relationId(rowTenant as { id: string } | string) === tenantId;\n}\n\nexport function relationMatch(value: unknown, target: string | undefined): boolean {\n  return target ? relationId(value as { id: string } | string) === target : false;\n}\n\nexport function lowerSlug(value: string): string {\n  return (\n    value\n      .trim()\n      .toLowerCase()\n      .replace(/[^a-z0-9]+/g, \"-\")\n      .replace(/^-+|-+$/g, \"\") || \"item\"\n  );\n}\n\nexport function isTimeValid(at: Date | undefined, startsAt?: Date, expiresAt?: Date): boolean {\n  const instant = at ?? new Date();\n  if (startsAt && instant < startsAt) return false;\n  if (expiresAt && instant > expiresAt) return false;\n  return true;\n}\n\nexport function buildAccessContext(options: {\n  tenantId: string;\n  principalId: string;\n  permissions: EffectivePermissionSnapshot[];\n  grants: GrantSnapshot[];\n}): AccessContext {\n  const permissionsByScope: Record<string, string[]> = {};\n  const allowedOrgUnitIdsByPermission: Record<string, string[]> = {};\n\n  for (const permission of options.permissions) {\n    const key = scopeKey(permission.scopeKind, permission.scopeId);\n    permissionsByScope[key] = permissionsByScope[key] ?? [];\n    permissionsByScope[key].push(permission.permissionKey);\n    if (permission.scopeKind === ScopeKind.OrgUnit) {\n      allowedOrgUnitIdsByPermission[permission.permissionKey] =\n        allowedOrgUnitIdsByPermission[permission.permissionKey] ?? [];\n      allowedOrgUnitIdsByPermission[permission.permissionKey].push(permission.scopeId);\n    }\n  }\n\n  return {\n    tenantId: options.tenantId,\n    principalId: options.principalId,\n    permissionsByScope,\n    allowedOrgUnitIdsByPermission,\n      resourceGrants: options.grants.map((grant) => ({\n        resourceId: grant.resourceId,\n        permissionKey: grant.permissionKey,\n      })),\n  };\n}\n\nexport abstract class BaseModelService<M extends Model<boolean> & { id: string }> extends ModelService<\n  M,\n  Repository<M, any>\n> {\n  protected constructor(clazz: new () => M) {\n    super(clazz);\n  }\n\n  protected newModel<T>(clazz: new () => T, data: Partial<T>): T {\n    return Object.assign(new clazz() as object, data as object) as T;\n  }\n\n  async create(data: Partial<M>, ...args: any[]): Promise<M> {\n    return this.repo.create(Object.assign({} as M, data as object), ...args);\n  }\n\n  async createOne(data: Partial<M>, ...args: any[]): Promise<M> {\n    return this.create(data, ...args);\n  }\n\n  async getById(id: string, ...args: any[]): Promise<M> {\n    return this.repo.read(id, ...args);\n  }\n\n  async updateOne(id: string, patch: Partial<M>, ...args: any[]): Promise<M> {\n    const existing = await this.repo.read(id, ...args);\n    return this.repo.update(Object.assign(existing, patch), ...args);\n  }\n\n  async deleteById(id: string, ...args: any[]): Promise<void> {\n    await this.repo.delete(id, ...args);\n  }\n\n  async findOneBy<K extends keyof M & string>(key: K, value: M[K], ...args: any[]): Promise<M> {\n    return this.repo.findOneBy(key, value, ...args);\n  }\n\n  async findManyBy<K extends keyof M & string>(key: K, value: M[K], ...args: any[]): Promise<M[]> {\n    return this.repo.select().where({ [key]: value } as any).execute(...args);\n  }\n\n  async listAll(...args: any[]): Promise<M[]> {\n    return this.repo.select().execute(...args);\n  }\n}\n\nexport function id(): string {\n  return crypto.randomUUID();\n}\n\nexport function relationId(value: string | { id: string }): string {\n  return typeof value === \"string\" ? value : value.id;\n}\n\nexport { AuthorizationError, transactional } from \"@decaf-ts/core\";\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["utils.js"],"names":[],"mappings":"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","sourcesContent":["import { Cascade, ModelService } from \"@decaf-ts/core\";\nimport { ScopeKind, } from \"./types.js\";\nexport const REL_RESTRICT = {\n    update: Cascade.NONE,\n    delete: Cascade.NONE,\n    nullable: false,\n};\nexport const REL_NULLIFY = {\n    update: Cascade.NONE,\n    delete: Cascade.NONE,\n    nullable: true,\n};\nexport const REL_CASCADE_DEPENDENT = {\n    update: Cascade.CASCADE,\n    delete: Cascade.CASCADE,\n    nullable: false,\n};\nexport const REL_CASCADE_INSERT_UPDATE = {\n    update: Cascade.CASCADE,\n    delete: Cascade.NONE,\n    nullable: false,\n};\nexport function buildArangoContext(options) {\n    return {\n        tenantId: options.tenantId,\n        principalId: options.principalId,\n        permissionKey: options.permissionKey,\n        allowedOrgUnitIds: [...options.allowedOrgUnitIds],\n        allowedResourceIds: [...options.allowedResourceIds],\n    };\n}\nexport function buildQdrantFilter(options) {\n    return {\n        must: [\n            {\n                key: \"tenant_id\",\n                match: { value: options.tenantId },\n            },\n            {\n                should: [\n                    { key: \"org_unit_id\", match: { any: options.allowedOrgUnitIds } },\n                    { key: \"protected_resource_id\", match: { any: options.allowedResourceIds } },\n                    { key: \"owner_principal_id\", match: { value: options.principalId } },\n                ],\n            },\n        ],\n    };\n}\nfunction scopeKey(scopeKind, scopeId) {\n    return `${scopeKind}:${scopeId}`;\n}\nexport function nowIso() {\n    return new Date();\n}\nexport function asArray(value) {\n    return value ?? [];\n}\nexport function sameTenant(rowTenant, tenantId) {\n    return relationId(rowTenant) === tenantId;\n}\nexport function relationMatch(value, target) {\n    return target ? relationId(value) === target : false;\n}\nexport function lowerSlug(value) {\n    return (value\n        .trim()\n        .toLowerCase()\n        .replace(/[^a-z0-9]+/g, \"-\")\n        .replace(/^-+|-+$/g, \"\") || \"item\");\n}\nexport function isTimeValid(at, startsAt, expiresAt) {\n    const instant = at ?? new Date();\n    if (startsAt && instant < startsAt)\n        return false;\n    if (expiresAt && instant > expiresAt)\n        return false;\n    return true;\n}\nexport function buildAccessContext(options) {\n    const permissionsByScope = {};\n    const allowedOrgUnitIdsByPermission = {};\n    for (const permission of options.permissions) {\n        const key = scopeKey(permission.scopeKind, permission.scopeId);\n        permissionsByScope[key] = permissionsByScope[key] ?? [];\n        permissionsByScope[key].push(permission.permissionKey);\n        if (permission.scopeKind === ScopeKind.OrgUnit) {\n            allowedOrgUnitIdsByPermission[permission.permissionKey] =\n                allowedOrgUnitIdsByPermission[permission.permissionKey] ?? [];\n            allowedOrgUnitIdsByPermission[permission.permissionKey].push(permission.scopeId);\n        }\n    }\n    return {\n        tenantId: options.tenantId,\n        principalId: options.principalId,\n        permissionsByScope,\n        allowedOrgUnitIdsByPermission,\n        resourceGrants: options.grants.map((grant) => ({\n            resourceId: grant.resourceId,\n            permissionKey: grant.permissionKey,\n        })),\n    };\n}\nexport class BaseModelService extends ModelService {\n    constructor(clazz) {\n        super(clazz);\n    }\n    newModel(clazz, data) {\n        return Object.assign(new clazz(), data);\n    }\n    async create(data, ...args) {\n        return this.repo.create(Object.assign({}, data), ...args);\n    }\n    async createOne(data, ...args) {\n        return this.create(data, ...args);\n    }\n    async getById(id, ...args) {\n        return this.repo.read(id, ...args);\n    }\n    async updateOne(id, patch, ...args) {\n        const existing = await this.repo.read(id, ...args);\n        return this.repo.update(Object.assign(existing, patch), ...args);\n    }\n    async deleteById(id, ...args) {\n        await this.repo.delete(id, ...args);\n    }\n    async findOneBy(key, value, ...args) {\n        return this.repo.findOneBy(key, value, ...args);\n    }\n    async findManyBy(key, value, ...args) {\n        return this.repo.select().where({ [key]: value }).execute(...args);\n    }\n    async listAll(...args) {\n        return this.repo.select().execute(...args);\n    }\n}\nexport function id() {\n    return crypto.randomUUID();\n}\nexport function relationId(value) {\n    return typeof value === \"string\" ? value : value.id;\n}\nexport { AuthorizationError, transactional } from \"@decaf-ts/core\";\n//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../src/namespaces/utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { AuthorizationError, Cascade, ModelService, Repository } from \"@decaf-ts/core\";\nimport { Model } from \"@decaf-ts/decorator-validation\";\nimport {\n  AccessContext,\n  ArangoAuthContext,\n  EffectivePermissionSnapshot,\n  GrantSnapshot,\n  QdrantAuthFilter,\n  ResourceVisibility,\n  ScopeKind,\n} from \"./types\";\n\nexport const REL_RESTRICT = {\n  update: Cascade.NONE,\n  delete: Cascade.NONE,\n  nullable: false,\n} as const;\n\nexport const REL_NULLIFY = {\n  update: Cascade.NONE,\n  delete: Cascade.NONE,\n  nullable: true,\n} as const;\n\nexport const REL_CASCADE_DEPENDENT = {\n  update: Cascade.CASCADE,\n  delete: Cascade.CASCADE,\n  nullable: false,\n} as const;\n\nexport const REL_CASCADE_INSERT_UPDATE = {\n  update: Cascade.CASCADE,\n  delete: Cascade.NONE,\n  nullable: false,\n} as const;\n\nexport function buildArangoContext(options: {\n  tenantId: string;\n  principalId: string;\n  permissionKey: string;\n  allowedOrgUnitIds: string[];\n  allowedResourceIds: string[];\n}): ArangoAuthContext {\n  return {\n    tenantId: options.tenantId,\n    principalId: options.principalId,\n    permissionKey: options.permissionKey,\n    allowedOrgUnitIds: [...options.allowedOrgUnitIds],\n    allowedResourceIds: [...options.allowedResourceIds],\n  };\n}\n\nexport function buildQdrantFilter(options: {\n  tenantId: string;\n  principalId: string;\n  permissionKey: string;\n  allowedOrgUnitIds: string[];\n  allowedResourceIds: string[];\n}): QdrantAuthFilter {\n  return {\n    must: [\n      {\n        key: \"tenant_id\",\n        match: { value: options.tenantId },\n      },\n      {\n        should: [\n          { key: \"org_unit_id\", match: { any: options.allowedOrgUnitIds } },\n          { key: \"protected_resource_id\", match: { any: options.allowedResourceIds } },\n          { key: \"owner_principal_id\", match: { value: options.principalId } },\n        ],\n      },\n    ],\n  };\n}\n\nfunction scopeKey(scopeKind: ScopeKind, scopeId: string): string {\n  return `${scopeKind}:${scopeId}`;\n}\n\nexport function nowIso(): Date {\n  return new Date();\n}\n\nexport function asArray<T>(value: T[] | undefined): T[] {\n  return value ?? [];\n}\n\nexport function sameTenant(rowTenant: unknown, tenantId: string): boolean {\n  return relationId(rowTenant as { id: string } | string) === tenantId;\n}\n\nexport function relationMatch(value: unknown, target: string | undefined): boolean {\n  return target ? relationId(value as { id: string } | string) === target : false;\n}\n\nexport function lowerSlug(value: string): string {\n  return (\n    value\n      .trim()\n      .toLowerCase()\n      .replace(/[^a-z0-9]+/g, \"-\")\n      .replace(/^-+|-+$/g, \"\") || \"item\"\n  );\n}\n\nexport function isTimeValid(at: Date | undefined, startsAt?: Date, expiresAt?: Date): boolean {\n  const instant = at ?? new Date();\n  if (startsAt && instant < startsAt) return false;\n  if (expiresAt && instant > expiresAt) return false;\n  return true;\n}\n\nexport function buildAccessContext(options: {\n  tenantId: string;\n  principalId: string;\n  permissions: EffectivePermissionSnapshot[];\n  grants: GrantSnapshot[];\n}): AccessContext {\n  const permissionsByScope: Record<string, string[]> = {};\n  const allowedOrgUnitIdsByPermission: Record<string, string[]> = {};\n\n  for (const permission of options.permissions) {\n    const key = scopeKey(permission.scopeKind, permission.scopeId);\n    permissionsByScope[key] = permissionsByScope[key] ?? [];\n    permissionsByScope[key].push(permission.permissionKey);\n    if (permission.scopeKind === ScopeKind.OrgUnit) {\n      allowedOrgUnitIdsByPermission[permission.permissionKey] =\n        allowedOrgUnitIdsByPermission[permission.permissionKey] ?? [];\n      allowedOrgUnitIdsByPermission[permission.permissionKey].push(permission.scopeId);\n    }\n  }\n\n  return {\n    tenantId: options.tenantId,\n    principalId: options.principalId,\n    permissionsByScope,\n    allowedOrgUnitIdsByPermission,\n      resourceGrants: options.grants.map((grant) => ({\n        resourceId: grant.resourceId,\n        permissionKey: grant.permissionKey,\n      })),\n  };\n}\n\nexport abstract class BaseModelService<M extends Model<boolean> & { id: string }> extends ModelService<\n  M,\n  Repository<M, any>\n> {\n  protected constructor(clazz: new () => M) {\n    super(clazz);\n  }\n\n  protected newModel<T>(clazz: new () => T, data: Partial<T>): T {\n    return Object.assign(new clazz() as object, data as object) as T;\n  }\n\n  async create(data: Partial<M>, ...args: any[]): Promise<M> {\n    return this.repo.create(Object.assign({} as M, data as object), ...args);\n  }\n\n  async createOne(data: Partial<M>, ...args: any[]): Promise<M> {\n    return this.create(data, ...args);\n  }\n\n  async getById(id: string, ...args: any[]): Promise<M> {\n    return this.repo.read(id, ...args);\n  }\n\n  async updateOne(id: string, patch: Partial<M>, ...args: any[]): Promise<M> {\n    const existing = await this.repo.read(id, ...args);\n    return this.repo.update(Object.assign(existing, patch), ...args);\n  }\n\n  async deleteById(id: string, ...args: any[]): Promise<void> {\n    await this.repo.delete(id, ...args);\n  }\n\n  async findOneBy<K extends keyof M & string>(key: K, value: M[K], ...args: any[]): Promise<M> {\n    return this.repo.findOneBy(key, value, ...args);\n  }\n\n  async findManyBy<K extends keyof M & string>(key: K, value: M[K], ...args: any[]): Promise<M[]> {\n    return this.repo.select().where({ [key]: value } as any).execute(...args);\n  }\n\n  async listAll(...args: any[]): Promise<M[]> {\n    return this.repo.select().execute(...args);\n  }\n}\n\nexport function id(): string {\n  return crypto.randomUUID();\n}\n\nexport function relationId(value: string | { id: string }): string {\n  return typeof value === \"string\" ? value : value.id;\n}\n\nexport { AuthorizationError, transactional } from \"@decaf-ts/core\";\n"]}"]}

package/lib/cjs/nest/authService.cjs

@@ -87,5 +87,5 @@ class AuthService {
     }
 }
 exports.AuthService = AuthService;
-//# sourceMappingURL=authService.js.map
-//# sourceMappingURL=authService.cjs.map
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"authService.js","sourceRoot":"","sources":["../../../src/nest/authService.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,EAAE,kBAAkB,EAAE,SAAS,EAAE,MAAM,MAAM,CAAC;AACrD,OAAO,EACL,oBAAoB,EACpB,kBAAkB,EAClB,eAAe,EACf,OAAO,EACP,cAAc,GACf,mBAAgB;AA+BjB,MAAM,OAAO,WAAW;IAOtB,YAAY,UAA8B,EAAE;QAC1C,IAAI,CAAC,WAAW,GAAG,CAAC,CAAC,OAAO,CAAC,WAAW,IAAI,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC;QAChE,IAAI,CAAC,SAAS,GAAG,OAAO,CAAC,SAAS,IAAI,EAAE,CAAC;QACzC,IAAI,CAAC,qBAAqB,GAAG,OAAO,CAAC,qBAAqB,IAAI,CAAC,CAAC;QAChE,IAAI,CAAC,eAAe,GAAG,OAAO,CAAC,eAAe,IAAI,CAAC,SAAS,CAAC,CAAC;IAChE,CAAC;IAED,0BAA0B;QACxB,OAAO,IAAI,CAAC,WAAW,CAAC;IAC1B,CAAC;IAED,eAAe,CAAC,GAAW;QACzB,OAAO,eAAe,CAAC,GAAG,CAAC,CAAC;IAC9B,CAAC;IAED,QAAQ,CAAC,GAAW;QAClB,OAAO,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC,CAAC;IAC9D,CAAC;IAED,OAAO,CAAC,GAAW;QACjB,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC;IACtB,CAAC;IAED,oBAAoB,CAAC,OAA0C;QAC7D,OAAO,oBAAoB,CAAC,OAAO,CAAC,CAAC;IACvC,CAAC;IAED;;;OAGG;IACH,kBAAkB,CAChB,OAA0C;QAE1C,OAAO,cAAc,CAAC,OAAO,EAAE,IAAI,CAAC,eAAe,CAAC,CAAC;IACvD,CAAC;IAED,kBAAkB,CAAC,GAAW;QAC5B,OAAO,kBAAkB,CAAC,GAAG,CAAC,CAAC;IACjC,CAAC;IAED;;;;;;;;;OASG;IACH,KAAK,CAAC,gBAAgB,CACpB,GAAW;QAEX,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC;YACrB,OAAO,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC;QACrC,CAAC;QACD,MAAM,OAAO,GAAG,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC;QAC1C,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,MAAM,IAAI,kBAAkB,CAAC,eAAe,CAAC,CAAC;QAChD,CAAC;QACD,OAAO,OAAO,CAAC;IACjB,CAAC;IAED;;;OAGG;IACK,KAAK,CAAC,iBAAiB,CAC7B,GAAW;QAEX,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;YACf,IAAI,CAAC,IAAI,GAAG,kBAAkB,CAAC,IAAI,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC;QAC1D,CAAC;QACD,IAAI,CAAC;YACH,MAAM,EAAE,OAAO,EAAE,GAAG,MAAM,SAAS,CAAC,GAAG,EAAE,IAAI,CAAC,IAAI,EAAE;gBAClD,cAAc,EAAE,GAAG,IAAI,CAAC,qBAAqB,GAAG;aACjD,CAAC,CAAC;YACH,OAAO,OAAgD,CAAC;QAC1D,CAAC;QAAC,OAAO,CAAM,EAAE,CAAC;YAChB,MAAM,IAAI,kBAAkB,CAAC,iBAAiB,GAAG,CAAC,CAAC,EAAE,OAAO,IAAI,CAAC,CAAC,CAAC,CAAC;QACtE,CAAC;IACH,CAAC;CACF","sourcesContent":["/**\n * @module integrations/nest/authService\n * @summary Nest-compatible authentication service helpers.\n * @description Request-context-aware auth helpers for Nest applications using Decaf integration patterns.\n *\n * Supports two modes:\n * - **Verify mode** (default when `verifyUrl` is set): validates the JWT signature\n *   against the Keycloak JWKS endpoint using `jose.jwtVerify`.\n * - **Decode-only mode** (when `verifyToken` is false / `verifyUrl` is empty):\n *   decodes the JWT without signature verification (dev/local mode).\n */\nimport { AuthorizationError } from \"@decaf-ts/core\";\nimport { createRemoteJWKSet, jwtVerify } from \"jose\";\nimport {\n  extractKeycloakRoles,\n  getRealmFromIssuer,\n  getTokenPayload,\n  getUser,\n  getClientRoles,\n} from \"./utils\";\nimport type { KeycloakAccessTokenPayload, KeycloakUser } from \"./types\";\n\n/**\n * Configuration for the {@link AuthService}.\n */\nexport interface AuthServiceOptions {\n  /**\n   * Whether to verify the JWT signature against the Keycloak JWKS endpoint.\n   * When `false` (or `verifyUrl` is empty), tokens are decoded without\n   * signature verification (dev/local mode only).\n   * @default false\n   */\n  verifyToken?: boolean;\n  /**\n   * The Keycloak JWKS URL (e.g. `https://keycloak/realms/myrealm/protocol/openid-connect/certs`).\n   * Required when `verifyToken` is `true`.\n   */\n  verifyUrl?: string;\n  /**\n   * Clock tolerance for JWT expiry verification (in seconds).\n   * @default 5\n   */\n  clockToleranceSeconds?: number;\n  /**\n   * Keycloak client IDs to exclude when extracting roles from `resource_access`.\n   * @default [\"account\"]\n   */\n  excludedClients?: string[];\n}\n\nexport class AuthService {\n  private readonly verifyToken: boolean;\n  private readonly verifyUrl: string;\n  private readonly clockToleranceSeconds: number;\n  private readonly excludedClients: string[];\n  private jwks: ReturnType<typeof createRemoteJWKSet> | undefined;\n\n  constructor(options: AuthServiceOptions = {}) {\n    this.verifyToken = !!options.verifyToken && !!options.verifyUrl;\n    this.verifyUrl = options.verifyUrl ?? \"\";\n    this.clockToleranceSeconds = options.clockToleranceSeconds ?? 5;\n    this.excludedClients = options.excludedClients ?? [\"account\"];\n  }\n\n  isTokenVerificationEnabled(): boolean {\n    return this.verifyToken;\n  }\n\n  getTokenPayload(jwt: string): KeycloakAccessTokenPayload | null {\n    return getTokenPayload(jwt);\n  }\n\n  getRoles(jwt: string): string[] {\n    return this.extractKeycloakRoles(this.getTokenPayload(jwt));\n  }\n\n  getUser(jwt: string): KeycloakUser | undefined {\n    return getUser(jwt);\n  }\n\n  extractKeycloakRoles(payload: KeycloakAccessTokenPayload | null): string[] {\n    return extractKeycloakRoles(payload);\n  }\n\n  /**\n   * Extracts client roles from the `resource_access` claim, excluding\n   * the configured `excludedClients` (default: `[\"account\"]`).\n   */\n  extractClientRoles(\n    payload: KeycloakAccessTokenPayload | null\n  ): string[] {\n    return getClientRoles(payload, this.excludedClients);\n  }\n\n  getRealmFromIssuer(jwt: string): string {\n    return getRealmFromIssuer(jwt);\n  }\n\n  /**\n   * Validates a JWT:\n   * - In **verify mode**: verifies the signature against the Keycloak JWKS\n   *   endpoint using `jose.jwtVerify`, then returns the verified payload.\n   * - In **decode-only mode**: decodes the JWT without verification and\n   *   returns the payload (or throws if unparseable).\n   *\n   * @throws {AuthorizationError} when the token is invalid, expired, or\n   *   signature verification fails.\n   */\n  async assertValidToken(\n    jwt: string\n  ): Promise<KeycloakAccessTokenPayload> {\n    if (this.verifyToken) {\n      return this.verifyAgainstJwks(jwt);\n    }\n    const payload = this.getTokenPayload(jwt);\n    if (!payload) {\n      throw new AuthorizationError(\"Invalid token\");\n    }\n    return payload;\n  }\n\n  /**\n   * Verifies the JWT signature against the Keycloak JWKS endpoint.\n   * Lazily creates the JWKS keystore on first call.\n   */\n  private async verifyAgainstJwks(\n    jwt: string\n  ): Promise<KeycloakAccessTokenPayload> {\n    if (!this.jwks) {\n      this.jwks = createRemoteJWKSet(new URL(this.verifyUrl));\n    }\n    try {\n      const { payload } = await jwtVerify(jwt, this.jwks, {\n        clockTolerance: `${this.clockToleranceSeconds}s`,\n      });\n      return payload as unknown as KeycloakAccessTokenPayload;\n    } catch (e: any) {\n      throw new AuthorizationError(\"Invalid token: \" + (e?.message ?? e));\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"authService.js","sourceRoot":"","sources":["authService.js"],"names":[],"mappings":";;;AAAA;;;;;;;;;;GAUG;AACH,yCAAoD;AACpD,+BAAqD;AACrD,yCAAiH;AACjH,MAAa,WAAW;IACpB,YAAY,OAAO,GAAG,EAAE;QACpB,IAAI,CAAC,WAAW,GAAG,CAAC,CAAC,OAAO,CAAC,WAAW,IAAI,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC;QAChE,IAAI,CAAC,SAAS,GAAG,OAAO,CAAC,SAAS,IAAI,EAAE,CAAC;QACzC,IAAI,CAAC,qBAAqB,GAAG,OAAO,CAAC,qBAAqB,IAAI,CAAC,CAAC;QAChE,IAAI,CAAC,eAAe,GAAG,OAAO,CAAC,eAAe,IAAI,CAAC,SAAS,CAAC,CAAC;IAClE,CAAC;IACD,0BAA0B;QACtB,OAAO,IAAI,CAAC,WAAW,CAAC;IAC5B,CAAC;IACD,eAAe,CAAC,GAAG;QACf,OAAO,IAAA,0BAAe,EAAC,GAAG,CAAC,CAAC;IAChC,CAAC;IACD,QAAQ,CAAC,GAAG;QACR,OAAO,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC,CAAC;IAChE,CAAC;IACD,OAAO,CAAC,GAAG;QACP,OAAO,IAAA,kBAAO,EAAC,GAAG,CAAC,CAAC;IACxB,CAAC;IACD,oBAAoB,CAAC,OAAO;QACxB,OAAO,IAAA,+BAAoB,EAAC,OAAO,CAAC,CAAC;IACzC,CAAC;IACD;;;OAGG;IACH,kBAAkB,CAAC,OAAO;QACtB,OAAO,IAAA,yBAAc,EAAC,OAAO,EAAE,IAAI,CAAC,eAAe,CAAC,CAAC;IACzD,CAAC;IACD,kBAAkB,CAAC,GAAG;QAClB,OAAO,IAAA,6BAAkB,EAAC,GAAG,CAAC,CAAC;IACnC,CAAC;IACD;;;;;;;;;OASG;IACH,KAAK,CAAC,gBAAgB,CAAC,GAAG;QACtB,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC;YACnB,OAAO,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC;QACvC,CAAC;QACD,MAAM,OAAO,GAAG,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC;QAC1C,IAAI,CAAC,OAAO,EAAE,CAAC;YACX,MAAM,IAAI,yBAAkB,CAAC,eAAe,CAAC,CAAC;QAClD,CAAC;QACD,OAAO,OAAO,CAAC;IACnB,CAAC;IACD;;;OAGG;IACH,KAAK,CAAC,iBAAiB,CAAC,GAAG;QACvB,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;YACb,IAAI,CAAC,IAAI,GAAG,IAAA,yBAAkB,EAAC,IAAI,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC;QAC5D,CAAC;QACD,IAAI,CAAC;YACD,MAAM,EAAE,OAAO,EAAE,GAAG,MAAM,IAAA,gBAAS,EAAC,GAAG,EAAE,IAAI,CAAC,IAAI,EAAE;gBAChD,cAAc,EAAE,GAAG,IAAI,CAAC,qBAAqB,GAAG;aACnD,CAAC,CAAC;YACH,OAAO,OAAO,CAAC;QACnB,CAAC;QACD,OAAO,CAAC,EAAE,CAAC;YACP,MAAM,IAAI,yBAAkB,CAAC,iBAAiB,GAAG,CAAC,CAAC,EAAE,OAAO,IAAI,CAAC,CAAC,CAAC,CAAC;QACxE,CAAC;IACL,CAAC;CACJ;AAtED,kCAsEC;AACD,0sRAA0sR","sourcesContent":["/**\n * @module integrations/nest/authService\n * @summary Nest-compatible authentication service helpers.\n * @description Request-context-aware auth helpers for Nest applications using Decaf integration patterns.\n *\n * Supports two modes:\n * - **Verify mode** (default when `verifyUrl` is set): validates the JWT signature\n *   against the Keycloak JWKS endpoint using `jose.jwtVerify`.\n * - **Decode-only mode** (when `verifyToken` is false / `verifyUrl` is empty):\n *   decodes the JWT without signature verification (dev/local mode).\n */\nimport { AuthorizationError } from \"@decaf-ts/core\";\nimport { createRemoteJWKSet, jwtVerify } from \"jose\";\nimport { extractKeycloakRoles, getRealmFromIssuer, getTokenPayload, getUser, getClientRoles, } from \"./utils.js\";\nexport class AuthService {\n    constructor(options = {}) {\n        this.verifyToken = !!options.verifyToken && !!options.verifyUrl;\n        this.verifyUrl = options.verifyUrl ?? \"\";\n        this.clockToleranceSeconds = options.clockToleranceSeconds ?? 5;\n        this.excludedClients = options.excludedClients ?? [\"account\"];\n    }\n    isTokenVerificationEnabled() {\n        return this.verifyToken;\n    }\n    getTokenPayload(jwt) {\n        return getTokenPayload(jwt);\n    }\n    getRoles(jwt) {\n        return this.extractKeycloakRoles(this.getTokenPayload(jwt));\n    }\n    getUser(jwt) {\n        return getUser(jwt);\n    }\n    extractKeycloakRoles(payload) {\n        return extractKeycloakRoles(payload);\n    }\n    /**\n     * Extracts client roles from the `resource_access` claim, excluding\n     * the configured `excludedClients` (default: `[\"account\"]`).\n     */\n    extractClientRoles(payload) {\n        return getClientRoles(payload, this.excludedClients);\n    }\n    getRealmFromIssuer(jwt) {\n        return getRealmFromIssuer(jwt);\n    }\n    /**\n     * Validates a JWT:\n     * - In **verify mode**: verifies the signature against the Keycloak JWKS\n     *   endpoint using `jose.jwtVerify`, then returns the verified payload.\n     * - In **decode-only mode**: decodes the JWT without verification and\n     *   returns the payload (or throws if unparseable).\n     *\n     * @throws {AuthorizationError} when the token is invalid, expired, or\n     *   signature verification fails.\n     */\n    async assertValidToken(jwt) {\n        if (this.verifyToken) {\n            return this.verifyAgainstJwks(jwt);\n        }\n        const payload = this.getTokenPayload(jwt);\n        if (!payload) {\n            throw new AuthorizationError(\"Invalid token\");\n        }\n        return payload;\n    }\n    /**\n     * Verifies the JWT signature against the Keycloak JWKS endpoint.\n     * Lazily creates the JWKS keystore on first call.\n     */\n    async verifyAgainstJwks(jwt) {\n        if (!this.jwks) {\n            this.jwks = createRemoteJWKSet(new URL(this.verifyUrl));\n        }\n        try {\n            const { payload } = await jwtVerify(jwt, this.jwks, {\n                clockTolerance: `${this.clockToleranceSeconds}s`,\n            });\n            return payload;\n        }\n        catch (e) {\n            throw new AuthorizationError(\"Invalid token: \" + (e?.message ?? e));\n        }\n    }\n}\n//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"authService.js","sourceRoot":"","sources":["../../../src/nest/authService.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,EAAE,kBAAkB,EAAE,SAAS,EAAE,MAAM,MAAM,CAAC;AACrD,OAAO,EACL,oBAAoB,EACpB,kBAAkB,EAClB,eAAe,EACf,OAAO,EACP,cAAc,GACf,mBAAgB;AA+BjB,MAAM,OAAO,WAAW;IAOtB,YAAY,UAA8B,EAAE;QAC1C,IAAI,CAAC,WAAW,GAAG,CAAC,CAAC,OAAO,CAAC,WAAW,IAAI,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC;QAChE,IAAI,CAAC,SAAS,GAAG,OAAO,CAAC,SAAS,IAAI,EAAE,CAAC;QACzC,IAAI,CAAC,qBAAqB,GAAG,OAAO,CAAC,qBAAqB,IAAI,CAAC,CAAC;QAChE,IAAI,CAAC,eAAe,GAAG,OAAO,CAAC,eAAe,IAAI,CAAC,SAAS,CAAC,CAAC;IAChE,CAAC;IAED,0BAA0B;QACxB,OAAO,IAAI,CAAC,WAAW,CAAC;IAC1B,CAAC;IAED,eAAe,CAAC,GAAW;QACzB,OAAO,eAAe,CAAC,GAAG,CAAC,CAAC;IAC9B,CAAC;IAED,QAAQ,CAAC,GAAW;QAClB,OAAO,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC,CAAC;IAC9D,CAAC;IAED,OAAO,CAAC,GAAW;QACjB,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC;IACtB,CAAC;IAED,oBAAoB,CAAC,OAA0C;QAC7D,OAAO,oBAAoB,CAAC,OAAO,CAAC,CAAC;IACvC,CAAC;IAED;;;OAGG;IACH,kBAAkB,CAChB,OAA0C;QAE1C,OAAO,cAAc,CAAC,OAAO,EAAE,IAAI,CAAC,eAAe,CAAC,CAAC;IACvD,CAAC;IAED,kBAAkB,CAAC,GAAW;QAC5B,OAAO,kBAAkB,CAAC,GAAG,CAAC,CAAC;IACjC,CAAC;IAED;;;;;;;;;OASG;IACH,KAAK,CAAC,gBAAgB,CACpB,GAAW;QAEX,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC;YACrB,OAAO,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC;QACrC,CAAC;QACD,MAAM,OAAO,GAAG,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC;QAC1C,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,MAAM,IAAI,kBAAkB,CAAC,eAAe,CAAC,CAAC;QAChD,CAAC;QACD,OAAO,OAAO,CAAC;IACjB,CAAC;IAED;;;OAGG;IACK,KAAK,CAAC,iBAAiB,CAC7B,GAAW;QAEX,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;YACf,IAAI,CAAC,IAAI,GAAG,kBAAkB,CAAC,IAAI,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC;QAC1D,CAAC;QACD,IAAI,CAAC;YACH,MAAM,EAAE,OAAO,EAAE,GAAG,MAAM,SAAS,CAAC,GAAG,EAAE,IAAI,CAAC,IAAI,EAAE;gBAClD,cAAc,EAAE,GAAG,IAAI,CAAC,qBAAqB,GAAG;aACjD,CAAC,CAAC;YACH,OAAO,OAAgD,CAAC;QAC1D,CAAC;QAAC,OAAO,CAAM,EAAE,CAAC;YAChB,MAAM,IAAI,kBAAkB,CAAC,iBAAiB,GAAG,CAAC,CAAC,EAAE,OAAO,IAAI,CAAC,CAAC,CAAC,CAAC;QACtE,CAAC;IACH,CAAC;CACF","sourcesContent":["/**\n * @module integrations/nest/authService\n * @summary Nest-compatible authentication service helpers.\n * @description Request-context-aware auth helpers for Nest applications using Decaf integration patterns.\n *\n * Supports two modes:\n * - **Verify mode** (default when `verifyUrl` is set): validates the JWT signature\n *   against the Keycloak JWKS endpoint using `jose.jwtVerify`.\n * - **Decode-only mode** (when `verifyToken` is false / `verifyUrl` is empty):\n *   decodes the JWT without signature verification (dev/local mode).\n */\nimport { AuthorizationError } from \"@decaf-ts/core\";\nimport { createRemoteJWKSet, jwtVerify } from \"jose\";\nimport {\n  extractKeycloakRoles,\n  getRealmFromIssuer,\n  getTokenPayload,\n  getUser,\n  getClientRoles,\n} from \"./utils\";\nimport type { KeycloakAccessTokenPayload, KeycloakUser } from \"./types\";\n\n/**\n * Configuration for the {@link AuthService}.\n */\nexport interface AuthServiceOptions {\n  /**\n   * Whether to verify the JWT signature against the Keycloak JWKS endpoint.\n   * When `false` (or `verifyUrl` is empty), tokens are decoded without\n   * signature verification (dev/local mode only).\n   * @default false\n   */\n  verifyToken?: boolean;\n  /**\n   * The Keycloak JWKS URL (e.g. `https://keycloak/realms/myrealm/protocol/openid-connect/certs`).\n   * Required when `verifyToken` is `true`.\n   */\n  verifyUrl?: string;\n  /**\n   * Clock tolerance for JWT expiry verification (in seconds).\n   * @default 5\n   */\n  clockToleranceSeconds?: number;\n  /**\n   * Keycloak client IDs to exclude when extracting roles from `resource_access`.\n   * @default [\"account\"]\n   */\n  excludedClients?: string[];\n}\n\nexport class AuthService {\n  private readonly verifyToken: boolean;\n  private readonly verifyUrl: string;\n  private readonly clockToleranceSeconds: number;\n  private readonly excludedClients: string[];\n  private jwks: ReturnType<typeof createRemoteJWKSet> | undefined;\n\n  constructor(options: AuthServiceOptions = {}) {\n    this.verifyToken = !!options.verifyToken && !!options.verifyUrl;\n    this.verifyUrl = options.verifyUrl ?? \"\";\n    this.clockToleranceSeconds = options.clockToleranceSeconds ?? 5;\n    this.excludedClients = options.excludedClients ?? [\"account\"];\n  }\n\n  isTokenVerificationEnabled(): boolean {\n    return this.verifyToken;\n  }\n\n  getTokenPayload(jwt: string): KeycloakAccessTokenPayload | null {\n    return getTokenPayload(jwt);\n  }\n\n  getRoles(jwt: string): string[] {\n    return this.extractKeycloakRoles(this.getTokenPayload(jwt));\n  }\n\n  getUser(jwt: string): KeycloakUser | undefined {\n    return getUser(jwt);\n  }\n\n  extractKeycloakRoles(payload: KeycloakAccessTokenPayload | null): string[] {\n    return extractKeycloakRoles(payload);\n  }\n\n  /**\n   * Extracts client roles from the `resource_access` claim, excluding\n   * the configured `excludedClients` (default: `[\"account\"]`).\n   */\n  extractClientRoles(\n    payload: KeycloakAccessTokenPayload | null\n  ): string[] {\n    return getClientRoles(payload, this.excludedClients);\n  }\n\n  getRealmFromIssuer(jwt: string): string {\n    return getRealmFromIssuer(jwt);\n  }\n\n  /**\n   * Validates a JWT:\n   * - In **verify mode**: verifies the signature against the Keycloak JWKS\n   *   endpoint using `jose.jwtVerify`, then returns the verified payload.\n   * - In **decode-only mode**: decodes the JWT without verification and\n   *   returns the payload (or throws if unparseable).\n   *\n   * @throws {AuthorizationError} when the token is invalid, expired, or\n   *   signature verification fails.\n   */\n  async assertValidToken(\n    jwt: string\n  ): Promise<KeycloakAccessTokenPayload> {\n    if (this.verifyToken) {\n      return this.verifyAgainstJwks(jwt);\n    }\n    const payload = this.getTokenPayload(jwt);\n    if (!payload) {\n      throw new AuthorizationError(\"Invalid token\");\n    }\n    return payload;\n  }\n\n  /**\n   * Verifies the JWT signature against the Keycloak JWKS endpoint.\n   * Lazily creates the JWKS keystore on first call.\n   */\n  private async verifyAgainstJwks(\n    jwt: string\n  ): Promise<KeycloakAccessTokenPayload> {\n    if (!this.jwks) {\n      this.jwks = createRemoteJWKSet(new URL(this.verifyUrl));\n    }\n    try {\n      const { payload } = await jwtVerify(jwt, this.jwks, {\n        clockTolerance: `${this.clockToleranceSeconds}s`,\n      });\n      return payload as unknown as KeycloakAccessTokenPayload;\n    } catch (e: any) {\n      throw new AuthorizationError(\"Invalid token: \" + (e?.message ?? e));\n    }\n  }\n}\n"]}"]}

package/lib/cjs/nest/graph/GraphExecutionController.cjs

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphExecutionController = exports.GRAPH_RESULT_REPOSITORY = void 0;
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+        r = Reflect.decorate(decorators, target, key, desc);
+    else
+        for (var i = decorators.length - 1; i >= 0; i--)
+            if (d = decorators[i])
+                r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+        return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); };
+};
+/**
+ * @module integrations/nest/graph/GraphExecutionController
+ * @summary NestJS controller bridging the graph execution engine to REST + SSE.
+ * @description Exposes three endpoints:
+ * - `POST /graph/execute` — triggers {@link GraphExecutionEngine.execute}, persists the result via a Decaf repository, and returns `{ runId, status, outputs }`.
+ * - `GET /graph/events` — SSE endpoint streaming {@link GraphExecutionEvent}s as `[modelName, operation, id, payload]` tuples (compatible with for-http's `ServerEventConnector`).
+ * - `GET /graph/results/:runId` — retrieves a persisted {@link GraphExecutionResultModel} from the repository.
+ *
+ * This is the production pattern: for-nest hosts the engine, for-angular consumes events over the network via SSE and fetches persisted results via REST.
+ */
+const common_1 = require("@nestjs/common");
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const index_js_1 = require("./../../graph/index.cjs");
+const GraphExecutionResultRepository_js_1 = require("./GraphExecutionResultRepository.cjs");
+/**
+ * NestJS injection token for the graph execution result repository.
+ */
+exports.GRAPH_RESULT_REPOSITORY = "GRAPH_RESULT_REPOSITORY";
+/**
+ * NestJS controller that hosts the graph execution engine server-side,
+ * streams events via SSE, and persists results for later retrieval.
+ */
+let GraphExecutionController = class GraphExecutionController {
+    constructor(engine, resultRepository) {
+        this.engine = engine;
+        this.resultRepository = resultRepository;
+        this.eventSubject = new rxjs_1.Subject();
+        this.engine.observe({
+            refresh: async (event) => {
+                this.eventSubject.next(event);
+            },
+        });
+    }
+    /**
+     * Triggers graph execution server-side, persists the result, and returns
+     * a summary containing the `runId`, `status`, and `outputs`.
+     */
+    async execute(body) {
+        const result = await this.engine.execute(body.workflow, body.inputs ?? {});
+        try {
+            await this.resultRepository.create((0, GraphExecutionResultRepository_js_1.toResultModel)(result));
+        }
+        catch {
+            // persistence failures must not mask a successful execution result
+        }
+        return {
+            runId: result.runId,
+            status: result.status,
+            outputs: result.outputs,
+        };
+    }
+    /**
+     * SSE endpoint that streams graph execution events.
+     *
+     * Events are serialized as `[modelName, operation, id, payload]` to match
+     * the format expected by for-http's `ServerEventConnector`.
+     */
+    events() {
+        return this.eventSubject.asObservable().pipe((0, operators_1.map)((event) => ({
+            type: "message",
+            data: JSON.stringify([
+                "graph",
+                event.type,
+                event.runId,
+                {
+                    id: event.id,
+                    sequence: event.sequence,
+                    type: event.type,
+                    runId: event.runId,
+                    parentRunId: event.parentRunId,
+                    workflowId: event.workflowId,
+                    nodeId: event.nodeId,
+                    edgeId: event.edgeId,
+                    port: event.port,
+                    iteration: event.iteration,
+                    path: event.path,
+                    status: event.status,
+                    payload: event.payload,
+                    error: event.error,
+                    timestamp: event.timestamp.toISOString(),
+                },
+            ]),
+        })));
+    }
+    /**
+     * Retrieves a persisted graph execution result by its `runId`.
+     *
+     * @throws {NotFoundException} when no result is stored for the given `runId`.
+     */
+    async getResult(runId) {
+        let model;
+        try {
+            model = (await this.resultRepository.read(runId));
+        }
+        catch {
+            model = null;
+        }
+        const result = (0, GraphExecutionResultRepository_js_1.fromResultModel)(model);
+        if (!result) {
+            throw new common_1.NotFoundException(`No graph execution result found for runId '${runId}'`);
+        }
+        return result;
+    }
+};
+exports.GraphExecutionController = GraphExecutionController;
+__decorate([
+    (0, common_1.Post)("execute"),
+    __param(0, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], GraphExecutionController.prototype, "execute", null);
+__decorate([
+    (0, common_1.Sse)("events"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", rxjs_1.Observable)
+], GraphExecutionController.prototype, "events", null);
+__decorate([
+    (0, common_1.Get)("results/:runId"),
+    __param(0, (0, common_1.Param)("runId")),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], GraphExecutionController.prototype, "getResult", null);
+exports.GraphExecutionController = GraphExecutionController = __decorate([
+    (0, common_1.Controller)("graph"),
+    __param(1, (0, common_1.Inject)(exports.GRAPH_RESULT_REPOSITORY)),
+    __metadata("design:paramtypes", [index_js_1.GraphExecutionEngine, Object])
+], GraphExecutionController);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"GraphExecutionController.js","sourceRoot":"","sources":["../../../../src/nest/graph/GraphExecutionController.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @module integrations/nest/graph/GraphExecutionController\n * @summary NestJS controller bridging the graph execution engine to REST + SSE.\n * @description Exposes three endpoints:\n * - `POST /graph/execute` — triggers {@link GraphExecutionEngine.execute}, persists the result via a Decaf repository, and returns `{ runId, status, outputs }`.\n * - `GET /graph/events` — SSE endpoint streaming {@link GraphExecutionEvent}s as `[modelName, operation, id, payload]` tuples (compatible with for-http's `ServerEventConnector`).\n * - `GET /graph/results/:runId` — retrieves a persisted {@link GraphExecutionResultModel} from the repository.\n *\n * This is the production pattern: for-nest hosts the engine, for-angular consumes events over the network via SSE and fetches persisted results via REST.\n */\nimport {\n  Controller,\n  Post,\n  Get,\n  Body,\n  Param,\n  Sse,\n  MessageEvent,\n  Inject,\n  NotFoundException,\n} from \"@nestjs/common\";\nimport { Subject, Observable } from \"rxjs\";\nimport { map } from \"rxjs/operators\";\n\nimport {\n  GraphExecutionEngine,\n  type GraphExecutionEvent,\n  type GraphExecutionValues,\n} from \"../../graph\";\nimport type { GraphWorkflowDefinition } from \"@decaf-ts/ui-decorators/graph\";\n\nimport {\n  fromResultModel,\n  toResultModel,\n  type GraphExecutionResultRepositoryInstance,\n} from \"./GraphExecutionResultRepository\";\nimport type { GraphExecutionResultModel } from \"./GraphExecutionResultModel\";\n\n/**\n * NestJS injection token for the graph execution result repository.\n */\nexport const GRAPH_RESULT_REPOSITORY = \"GRAPH_RESULT_REPOSITORY\";\n\n/**\n * Payload for the `POST /graph/execute` endpoint.\n */\nexport interface GraphExecutePayload {\n  workflow: GraphWorkflowDefinition;\n  inputs: GraphExecutionValues;\n}\n\n/**\n * Response shape for the `POST /graph/execute` endpoint.\n */\nexport interface GraphExecuteResponse {\n  runId: string;\n  status: string;\n  outputs: Record<string, unknown>;\n}\n\n/**\n * NestJS controller that hosts the graph execution engine server-side,\n * streams events via SSE, and persists results for later retrieval.\n */\n@Controller(\"graph\")\nexport class GraphExecutionController {\n  private readonly eventSubject = new Subject<GraphExecutionEvent>();\n\n  constructor(\n    private readonly engine: GraphExecutionEngine,\n    @Inject(GRAPH_RESULT_REPOSITORY)\n    private readonly resultRepository: GraphExecutionResultRepositoryInstance\n  ) {\n    this.engine.observe({\n      refresh: async (event) => {\n        this.eventSubject.next(event);\n      },\n    });\n  }\n\n  /**\n   * Triggers graph execution server-side, persists the result, and returns\n   * a summary containing the `runId`, `status`, and `outputs`.\n   */\n  @Post(\"execute\")\n  async execute(\n    @Body() body: GraphExecutePayload\n  ): Promise<GraphExecuteResponse> {\n    const result = await this.engine.execute(body.workflow, body.inputs ?? {});\n\n    try {\n      await this.resultRepository.create(toResultModel(result));\n    } catch {\n      // persistence failures must not mask a successful execution result\n    }\n\n    return {\n      runId: result.runId,\n      status: result.status,\n      outputs: result.outputs,\n    };\n  }\n\n  /**\n   * SSE endpoint that streams graph execution events.\n   *\n   * Events are serialized as `[modelName, operation, id, payload]` to match\n   * the format expected by for-http's `ServerEventConnector`.\n   */\n  @Sse(\"events\")\n  events(): Observable<MessageEvent> {\n    return this.eventSubject.asObservable().pipe(\n      map(\n        (event: GraphExecutionEvent): MessageEvent => ({\n          type: \"message\",\n          data: JSON.stringify([\n            \"graph\",\n            event.type,\n            event.runId,\n            {\n              id: event.id,\n              sequence: event.sequence,\n              type: event.type,\n              runId: event.runId,\n              parentRunId: event.parentRunId,\n              workflowId: event.workflowId,\n              nodeId: event.nodeId,\n              edgeId: event.edgeId,\n              port: event.port,\n              iteration: event.iteration,\n              path: event.path,\n              status: event.status,\n              payload: event.payload,\n              error: event.error,\n              timestamp: event.timestamp.toISOString(),\n            },\n          ]),\n        })\n      )\n    );\n  }\n\n  /**\n   * Retrieves a persisted graph execution result by its `runId`.\n   *\n   * @throws {NotFoundException} when no result is stored for the given `runId`.\n   */\n  @Get(\"results/:runId\")\n  async getResult(@Param(\"runId\") runId: string): Promise<unknown> {\n    let model: GraphExecutionResultModel | null;\n    try {\n      model = (await this.resultRepository.read(\n        runId\n      )) as GraphExecutionResultModel | null;\n    } catch {\n      model = null;\n    }\n    const result = fromResultModel(model);\n    if (!result) {\n      throw new NotFoundException(\n        `No graph execution result found for runId '${runId}'`\n      );\n    }\n    return result;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"GraphExecutionController.js","sourceRoot":"","sources":["GraphExecutionController.js"],"names":[],"mappings":"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","sourcesContent":["var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\n};\nvar __metadata = (this && this.__metadata) || function (k, v) {\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(k, v);\n};\nvar __param = (this && this.__param) || function (paramIndex, decorator) {\n    return function (target, key) { decorator(target, key, paramIndex); }\n};\n/**\n * @module integrations/nest/graph/GraphExecutionController\n * @summary NestJS controller bridging the graph execution engine to REST + SSE.\n * @description Exposes three endpoints:\n * - `POST /graph/execute` — triggers {@link GraphExecutionEngine.execute}, persists the result via a Decaf repository, and returns `{ runId, status, outputs }`.\n * - `GET /graph/events` — SSE endpoint streaming {@link GraphExecutionEvent}s as `[modelName, operation, id, payload]` tuples (compatible with for-http's `ServerEventConnector`).\n * - `GET /graph/results/:runId` — retrieves a persisted {@link GraphExecutionResultModel} from the repository.\n *\n * This is the production pattern: for-nest hosts the engine, for-angular consumes events over the network via SSE and fetches persisted results via REST.\n */\nimport { Controller, Post, Get, Body, Param, Sse, Inject, NotFoundException, } from \"@nestjs/common\";\nimport { Subject, Observable } from \"rxjs\";\nimport { map } from \"rxjs/operators\";\nimport { GraphExecutionEngine, } from \"./../../graph/index.js\";\nimport { fromResultModel, toResultModel, } from \"./GraphExecutionResultRepository.js\";\n/**\n * NestJS injection token for the graph execution result repository.\n */\nexport const GRAPH_RESULT_REPOSITORY = \"GRAPH_RESULT_REPOSITORY\";\n/**\n * NestJS controller that hosts the graph execution engine server-side,\n * streams events via SSE, and persists results for later retrieval.\n */\nlet GraphExecutionController = class GraphExecutionController {\n    constructor(engine, resultRepository) {\n        this.engine = engine;\n        this.resultRepository = resultRepository;\n        this.eventSubject = new Subject();\n        this.engine.observe({\n            refresh: async (event) => {\n                this.eventSubject.next(event);\n            },\n        });\n    }\n    /**\n     * Triggers graph execution server-side, persists the result, and returns\n     * a summary containing the `runId`, `status`, and `outputs`.\n     */\n    async execute(body) {\n        const result = await this.engine.execute(body.workflow, body.inputs ?? {});\n        try {\n            await this.resultRepository.create(toResultModel(result));\n        }\n        catch {\n            // persistence failures must not mask a successful execution result\n        }\n        return {\n            runId: result.runId,\n            status: result.status,\n            outputs: result.outputs,\n        };\n    }\n    /**\n     * SSE endpoint that streams graph execution events.\n     *\n     * Events are serialized as `[modelName, operation, id, payload]` to match\n     * the format expected by for-http's `ServerEventConnector`.\n     */\n    events() {\n        return this.eventSubject.asObservable().pipe(map((event) => ({\n            type: \"message\",\n            data: JSON.stringify([\n                \"graph\",\n                event.type,\n                event.runId,\n                {\n                    id: event.id,\n                    sequence: event.sequence,\n                    type: event.type,\n                    runId: event.runId,\n                    parentRunId: event.parentRunId,\n                    workflowId: event.workflowId,\n                    nodeId: event.nodeId,\n                    edgeId: event.edgeId,\n                    port: event.port,\n                    iteration: event.iteration,\n                    path: event.path,\n                    status: event.status,\n                    payload: event.payload,\n                    error: event.error,\n                    timestamp: event.timestamp.toISOString(),\n                },\n            ]),\n        })));\n    }\n    /**\n     * Retrieves a persisted graph execution result by its `runId`.\n     *\n     * @throws {NotFoundException} when no result is stored for the given `runId`.\n     */\n    async getResult(runId) {\n        let model;\n        try {\n            model = (await this.resultRepository.read(runId));\n        }\n        catch {\n            model = null;\n        }\n        const result = fromResultModel(model);\n        if (!result) {\n            throw new NotFoundException(`No graph execution result found for runId '${runId}'`);\n        }\n        return result;\n    }\n};\n__decorate([\n    Post(\"execute\"),\n    __param(0, Body()),\n    __metadata(\"design:type\", Function),\n    __metadata(\"design:paramtypes\", [Object]),\n    __metadata(\"design:returntype\", Promise)\n], GraphExecutionController.prototype, \"execute\", null);\n__decorate([\n    Sse(\"events\"),\n    __metadata(\"design:type\", Function),\n    __metadata(\"design:paramtypes\", []),\n    __metadata(\"design:returntype\", Observable)\n], GraphExecutionController.prototype, \"events\", null);\n__decorate([\n    Get(\"results/:runId\"),\n    __param(0, Param(\"runId\")),\n    __metadata(\"design:type\", Function),\n    __metadata(\"design:paramtypes\", [String]),\n    __metadata(\"design:returntype\", Promise)\n], GraphExecutionController.prototype, \"getResult\", null);\nGraphExecutionController = __decorate([\n    Controller(\"graph\"),\n    __param(1, Inject(GRAPH_RESULT_REPOSITORY)),\n    __metadata(\"design:paramtypes\", [GraphExecutionEngine, Object])\n], GraphExecutionController);\nexport { GraphExecutionController };\n//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"GraphExecutionController.js","sourceRoot":"","sources":["../../../../src/nest/graph/GraphExecutionController.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @module integrations/nest/graph/GraphExecutionController\n * @summary NestJS controller bridging the graph execution engine to REST + SSE.\n * @description Exposes three endpoints:\n * - `POST /graph/execute` — triggers {@link GraphExecutionEngine.execute}, persists the result via a Decaf repository, and returns `{ runId, status, outputs }`.\n * - `GET /graph/events` — SSE endpoint streaming {@link GraphExecutionEvent}s as `[modelName, operation, id, payload]` tuples (compatible with for-http's `ServerEventConnector`).\n * - `GET /graph/results/:runId` — retrieves a persisted {@link GraphExecutionResultModel} from the repository.\n *\n * This is the production pattern: for-nest hosts the engine, for-angular consumes events over the network via SSE and fetches persisted results via REST.\n */\nimport {\n  Controller,\n  Post,\n  Get,\n  Body,\n  Param,\n  Sse,\n  MessageEvent,\n  Inject,\n  NotFoundException,\n} from \"@nestjs/common\";\nimport { Subject, Observable } from \"rxjs\";\nimport { map } from \"rxjs/operators\";\n\nimport {\n  GraphExecutionEngine,\n  type GraphExecutionEvent,\n  type GraphExecutionValues,\n} from \"../../graph\";\nimport type { GraphWorkflowDefinition } from \"@decaf-ts/ui-decorators/graph\";\n\nimport {\n  fromResultModel,\n  toResultModel,\n  type GraphExecutionResultRepositoryInstance,\n} from \"./GraphExecutionResultRepository\";\nimport type { GraphExecutionResultModel } from \"./GraphExecutionResultModel\";\n\n/**\n * NestJS injection token for the graph execution result repository.\n */\nexport const GRAPH_RESULT_REPOSITORY = \"GRAPH_RESULT_REPOSITORY\";\n\n/**\n * Payload for the `POST /graph/execute` endpoint.\n */\nexport interface GraphExecutePayload {\n  workflow: GraphWorkflowDefinition;\n  inputs: GraphExecutionValues;\n}\n\n/**\n * Response shape for the `POST /graph/execute` endpoint.\n */\nexport interface GraphExecuteResponse {\n  runId: string;\n  status: string;\n  outputs: Record<string, unknown>;\n}\n\n/**\n * NestJS controller that hosts the graph execution engine server-side,\n * streams events via SSE, and persists results for later retrieval.\n */\n@Controller(\"graph\")\nexport class GraphExecutionController {\n  private readonly eventSubject = new Subject<GraphExecutionEvent>();\n\n  constructor(\n    private readonly engine: GraphExecutionEngine,\n    @Inject(GRAPH_RESULT_REPOSITORY)\n    private readonly resultRepository: GraphExecutionResultRepositoryInstance\n  ) {\n    this.engine.observe({\n      refresh: async (event) => {\n        this.eventSubject.next(event);\n      },\n    });\n  }\n\n  /**\n   * Triggers graph execution server-side, persists the result, and returns\n   * a summary containing the `runId`, `status`, and `outputs`.\n   */\n  @Post(\"execute\")\n  async execute(\n    @Body() body: GraphExecutePayload\n  ): Promise<GraphExecuteResponse> {\n    const result = await this.engine.execute(body.workflow, body.inputs ?? {});\n\n    try {\n      await this.resultRepository.create(toResultModel(result));\n    } catch {\n      // persistence failures must not mask a successful execution result\n    }\n\n    return {\n      runId: result.runId,\n      status: result.status,\n      outputs: result.outputs,\n    };\n  }\n\n  /**\n   * SSE endpoint that streams graph execution events.\n   *\n   * Events are serialized as `[modelName, operation, id, payload]` to match\n   * the format expected by for-http's `ServerEventConnector`.\n   */\n  @Sse(\"events\")\n  events(): Observable<MessageEvent> {\n    return this.eventSubject.asObservable().pipe(\n      map(\n        (event: GraphExecutionEvent): MessageEvent => ({\n          type: \"message\",\n          data: JSON.stringify([\n            \"graph\",\n            event.type,\n            event.runId,\n            {\n              id: event.id,\n              sequence: event.sequence,\n              type: event.type,\n              runId: event.runId,\n              parentRunId: event.parentRunId,\n              workflowId: event.workflowId,\n              nodeId: event.nodeId,\n              edgeId: event.edgeId,\n              port: event.port,\n              iteration: event.iteration,\n              path: event.path,\n              status: event.status,\n              payload: event.payload,\n              error: event.error,\n              timestamp: event.timestamp.toISOString(),\n            },\n          ]),\n        })\n      )\n    );\n  }\n\n  /**\n   * Retrieves a persisted graph execution result by its `runId`.\n   *\n   * @throws {NotFoundException} when no result is stored for the given `runId`.\n   */\n  @Get(\"results/:runId\")\n  async getResult(@Param(\"runId\") runId: string): Promise<unknown> {\n    let model: GraphExecutionResultModel | null;\n    try {\n      model = (await this.resultRepository.read(\n        runId\n      )) as GraphExecutionResultModel | null;\n    } catch {\n      model = null;\n    }\n    const result = fromResultModel(model);\n    if (!result) {\n      throw new NotFoundException(\n        `No graph execution result found for runId '${runId}'`\n      );\n    }\n    return result;\n  }\n}\n"]}"]}