@burdenoff/be-sdk 2026.510.79

package/dist/middleware/index.d.ts

@@ -0,0 +1,3 @@
+export { c as cleanupExpiredTokens, a as createSecurityPlugin } from '../index-DSOpj8DI.js';
+export { C as CSPDirectives, M as MetricsMiddlewareConfig, a as MiddlewareConfig, S as SecurityMiddlewareConfig } from '../types-Bo2wkjSP.js';
+import 'elysia';

package/dist/middleware/index.js

@@ -0,0 +1,5 @@
+export { cleanupExpiredTokens, createSecurityPlugin } from '../chunk-2HANKZZM.js';
+import '../chunk-CBZNP6RF.js';
+import '../chunk-XE4OXN2W.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/middleware/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/notifications/index.d.ts

@@ -0,0 +1,4 @@
+import '../graphql-BAVrUgBF.js';
+import '../index-CHbVw5M7.js';
+export { G as GetNotificationsOptions, b as Notification, c as NotificationChannel, d as NotificationPriority, e as NotificationResponse, N as NotificationType, a as NotificationsModule, R as RecipientInput, S as SendChannelNotificationOptions, f as SendNotificationOptions, g as SendTemplateNotificationOptions, T as TenantNotificationsModule } from '../index-CyVEg86m.js';
+import 'graphql-request';

package/dist/notifications/index.js

@@ -0,0 +1,7 @@
+export { NotificationChannel, NotificationPriority, NotificationType, NotificationsModule, TenantNotificationsModule } from '../chunk-XC2YD6CF.js';
+import '../chunk-SAG6ZYWQ.js';
+import '../chunk-NGMEI42S.js';
+import '../chunk-CBZNP6RF.js';
+import '../chunk-XE4OXN2W.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/notifications/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/observability/index.d.ts

@@ -0,0 +1,3 @@
+export { M as Metrics, a as MetricsCollector, c as createMetricsPlugin, g as getCurrentMetrics, b as getMetricsForWindow, m as metricsCollector } from '../index-4gKQKZ2B.js';
+import 'elysia';
+import '../types-Bo2wkjSP.js';

package/dist/observability/index.js

@@ -0,0 +1,5 @@
+export { MetricsCollector, createMetricsPlugin, getCurrentMetrics, getMetricsForWindow, metricsCollector } from '../chunk-5LXDPGDH.js';
+import '../chunk-CBZNP6RF.js';
+import '../chunk-XE4OXN2W.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/observability/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/pino-logger-RYLGXPHZ.js

@@ -0,0 +1,5 @@
+export { createPinoLogger } from './chunk-SNEOLWXT.js';
+import './chunk-CBZNP6RF.js';
+import './chunk-XE4OXN2W.js';
+//# sourceMappingURL=pino-logger-RYLGXPHZ.js.map
+//# sourceMappingURL=pino-logger-RYLGXPHZ.js.map

package/dist/pino-logger-RYLGXPHZ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"pino-logger-RYLGXPHZ.js"}

package/dist/prisma/generator/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/prisma/generator/index.js

@@ -0,0 +1,228 @@
+#!/usr/bin/env node
+import { __name } from '../../chunk-XE4OXN2W.js';
+import generatorHelperPkg from '@prisma/generator-helper';
+import { mkdirSync, writeFileSync } from 'fs';
+import { dirname, resolve } from 'path';
+
+var { generatorHandler } = generatorHelperPkg;
+function validateOutputPath(outputPath) {
+  const resolvedPath = resolve(outputPath);
+  if (!resolvedPath.endsWith(".ts")) {
+    throw new Error(`Invalid output path: ${outputPath} must be a .ts file`);
+  }
+  const dangerousPaths = [
+    "/etc/",
+    "/usr/",
+    "/bin/",
+    "/sbin/",
+    "/var/",
+    "/root/",
+    "/boot/",
+    "/sys/",
+    "/proc/"
+  ];
+  if (dangerousPaths.some((dangerous) => resolvedPath.startsWith(dangerous))) {
+    throw new Error(`Invalid output path: ${outputPath} cannot write to system directories`);
+  }
+  return resolvedPath;
+}
+__name(validateOutputPath, "validateOutputPath");
+function safeMkdirSync(dirPath) {
+  const resolvedPath = resolve(dirPath);
+  const dangerousPaths = [
+    "/etc/",
+    "/usr/",
+    "/bin/",
+    "/sbin/",
+    "/var/",
+    "/root/",
+    "/boot/",
+    "/sys/",
+    "/proc/"
+  ];
+  if (dangerousPaths.some((dangerous) => resolvedPath.startsWith(dangerous))) {
+    throw new Error(`Cannot create directory in system path: ${dirPath}`);
+  }
+  mkdirSync(resolvedPath, {
+    recursive: true
+  });
+}
+__name(safeMkdirSync, "safeMkdirSync");
+function safeWriteFileSync(filePath, content) {
+  const validatedPath = validateOutputPath(filePath);
+  writeFileSync(validatedPath, content, "utf-8");
+}
+__name(safeWriteFileSync, "safeWriteFileSync");
+generatorHandler({
+  onManifest() {
+    return {
+      defaultOutput: "./src/generated/prisma-fields.ts",
+      prettyName: "Burdenoff Prisma Field Generator",
+      requiresGenerators: [
+        "prisma-client-js"
+      ]
+    };
+  },
+  async onGenerate(options) {
+    const { dmmf, generator } = options;
+    const configuredPath = generator.output?.value || "./src/generated/prisma-fields.ts";
+    const outputPath = validateOutputPath(configuredPath);
+    const modelFieldsMap = {};
+    for (const model of dmmf.datamodel.models) {
+      const scalarFields = [];
+      const relationFields = [];
+      for (const field of model.fields) {
+        if (field.kind === "object") {
+          relationFields.push(field.name);
+        } else {
+          scalarFields.push(field.name);
+        }
+      }
+      modelFieldsMap[model.name] = {
+        fields: scalarFields,
+        relations: relationFields
+      };
+    }
+    const fileContent = generateTypeScriptFile(modelFieldsMap);
+    const outputDir = dirname(outputPath);
+    safeMkdirSync(outputDir);
+    safeWriteFileSync(outputPath, fileContent);
+    console.info(`\u2705 [Burdenoff] Generated Prisma fields mapping at: ${outputPath}`);
+    console.info(`   Found ${Object.keys(modelFieldsMap).length} models`);
+    console.info(`   Total fields: ${Object.values(modelFieldsMap).reduce((sum, m) => sum + m.fields.length, 0)}`);
+    console.info(`   Total relations: ${Object.values(modelFieldsMap).reduce((sum, m) => sum + m.relations.length, 0)}`);
+  }
+});
+function generateTypeScriptFile(modelFieldsMap) {
+  const modelCount = Object.keys(modelFieldsMap).length;
+  const totalFields = Object.values(modelFieldsMap).reduce((sum, m) => sum + m.fields.length, 0);
+  const totalRelations = Object.values(modelFieldsMap).reduce((sum, m) => sum + m.relations.length, 0);
+  return `/**
+ * Auto-generated Prisma Model Fields
+ *
+ * This file is automatically generated by @burdenoff/be-sdk Prisma Field Generator
+ * DO NOT EDIT MANUALLY - Changes will be overwritten on next generation
+ *
+ * Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}
+ * Total models: ${modelCount}
+ * Total scalar fields: ${totalFields}
+ * Total relation fields: ${totalRelations}
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Type definition for model fields mapping
+ */
+export type ModelFieldsMap = Record<
+  string,
+  {
+    /** Scalar fields (string, number, Date, etc.) */
+    fields: string[];
+    /** Relation fields (references to other models) */
+    relations: string[];
+  }
+>;
+
+/**
+ * Mapping of all Prisma models to their fields
+ *
+ * This mapping is generated at build time from your Prisma schema
+ * and contains all models with their scalar and relation fields.
+ */
+export const modelFields: ModelFieldsMap = ${JSON.stringify(modelFieldsMap, null, 2)} as const;
+
+/**
+ * Get all scalar fields for a model
+ *
+ * @param modelName - Name of the Prisma model
+ * @param includeRelations - Whether to include relation fields (default: false)
+ * @returns Array of field names
+ * @throws Error if model is not found
+ *
+ * @example
+ * \`\`\`typescript
+ * const userFields = getModelFields('User');
+ * // Returns: ['id', 'email', 'name', 'createdAt', 'updatedAt']
+ *
+ * const userFieldsWithRelations = getModelFields('User', true);
+ * // Returns: ['id', 'email', 'name', 'createdAt', 'updatedAt', 'posts', 'profile']
+ * \`\`\`
+ */
+export function getModelFields(modelName: string, includeRelations = false): string[] {
+  const model = modelFields[modelName];
+  if (!model) {
+    const available = Object.keys(modelFields).join(', ');
+    throw new Error(
+      \`Model "\${modelName}" not found in generated fields. Available models: \${available}\`
+    );
+  }
+
+  return includeRelations ? [...model.fields, ...model.relations] : model.fields;
+}
+
+/**
+ * Get all model names
+ *
+ * @returns Array of all available model names
+ *
+ * @example
+ * \`\`\`typescript
+ * const models = getAllModelNames();
+ * // Returns: ['User', 'Post', 'Comment', 'Tag', ...]
+ * \`\`\`
+ */
+export function getAllModelNames(): string[] {
+  return Object.keys(modelFields);
+}
+
+/**
+ * Check if a model exists in the schema
+ *
+ * @param modelName - Name of the model to check
+ * @returns True if model exists, false otherwise
+ *
+ * @example
+ * \`\`\`typescript
+ * if (hasModel('User')) {
+ *   const fields = getModelFields('User');
+ * }
+ * \`\`\`
+ */
+export function hasModel(modelName: string): boolean {
+  return modelName in modelFields;
+}
+
+/**
+ * Get only scalar fields (excludes relations)
+ *
+ * @param modelName - Name of the Prisma model
+ * @returns Array of scalar field names
+ */
+export function getScalarFields(modelName: string): string[] {
+  return getModelFields(modelName, false);
+}
+
+/**
+ * Get only relation fields
+ *
+ * @param modelName - Name of the Prisma model
+ * @returns Array of relation field names
+ */
+export function getRelationFields(modelName: string): string[] {
+  const model = modelFields[modelName];
+  if (!model) {
+    throw new Error(\`Model "\${modelName}" not found\`);
+  }
+  return model.relations;
+}
+
+/**
+ * Default export for convenience
+ */
+export default modelFields;
+`;
+}
+__name(generateTypeScriptFile, "generateTypeScriptFile");
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/prisma/generator/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/prisma/generator/index.ts"],"names":["generatorHandler","generatorHelperPkg","validateOutputPath","outputPath","resolvedPath","resolve","endsWith","Error","dangerousPaths","some","dangerous","startsWith","safeMkdirSync","dirPath","mkdirSync","recursive","safeWriteFileSync","filePath","content","validatedPath","writeFileSync","onManifest","defaultOutput","prettyName","requiresGenerators","onGenerate","options","dmmf","generator","configuredPath","output","value","modelFieldsMap","model","datamodel","models","scalarFields","relationFields","field","fields","kind","push","name","relations","fileContent","generateTypeScriptFile","outputDir","dirname","console","info","Object","keys","length","values","reduce","sum","m","modelCount","totalFields","totalRelations","Date","toISOString","JSON","stringify"],"mappings":"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","file":"index.js","sourcesContent":["#!/usr/bin/env node\n/**\n * Prisma Field Generator\n *\n * Generates a TypeScript file containing all model fields from Prisma schema.\n * This generator extracts DMMF information at build time and creates a static\n * mapping of model names to their fields, which can be used at runtime.\n *\n * Usage in schema.prisma:\n * ```prisma\n * generator fieldGenerator {\n *   provider = \"burdenoff-prisma-field-generator\"\n *   output   = \"./src/generated/prisma-fields.ts\"\n * }\n * ```\n */\n\nimport generatorHelperPkg from '@prisma/generator-helper';\nimport { writeFileSync, mkdirSync } from 'node:fs';\nimport { dirname, resolve } from 'node:path';\nimport type { GeneratorOptions } from '@prisma/generator-helper';\n\nconst { generatorHandler } = generatorHelperPkg;\n\n/**\n * Validate and resolve output path from generator config\n * Ensures the path is safe and within expected boundaries\n *\n * @param outputPath The output path from generator config\n * @returns Resolved absolute path\n */\nfunction validateOutputPath(outputPath: string): string {\n  // Resolve to absolute path\n  const resolvedPath = resolve(outputPath);\n\n  // Basic validation: ensure it's a TypeScript file\n  if (!resolvedPath.endsWith('.ts')) {\n    throw new Error(`Invalid output path: ${outputPath} must be a .ts file`);\n  }\n\n  // Ensure it doesn't try to write to system directories\n  const dangerousPaths = ['/etc/', '/usr/', '/bin/', '/sbin/', '/var/', '/root/', '/boot/', '/sys/', '/proc/'];\n  if (dangerousPaths.some((dangerous) => resolvedPath.startsWith(dangerous))) {\n    throw new Error(`Invalid output path: ${outputPath} cannot write to system directories`);\n  }\n\n  return resolvedPath;\n}\n\n/**\n * Safely create directory with validated path\n * Path validation prevents directory traversal attacks\n */\nfunction safeMkdirSync(dirPath: string): void {\n  const resolvedPath = resolve(dirPath);\n  // Validate it's not a system directory\n  const dangerousPaths = ['/etc/', '/usr/', '/bin/', '/sbin/', '/var/', '/root/', '/boot/', '/sys/', '/proc/'];\n  if (dangerousPaths.some((dangerous) => resolvedPath.startsWith(dangerous))) {\n    throw new Error(`Cannot create directory in system path: ${dirPath}`);\n  }\n  mkdirSync(resolvedPath, { recursive: true });\n}\n\n/**\n * Safely write file with validated path\n * Path validation prevents directory traversal attacks\n */\nfunction safeWriteFileSync(filePath: string, content: string): void {\n  const validatedPath = validateOutputPath(filePath);\n  writeFileSync(validatedPath, content, 'utf-8');\n}\n\ngeneratorHandler({\n  onManifest() {\n    return {\n      defaultOutput: './src/generated/prisma-fields.ts',\n      prettyName: 'Burdenoff Prisma Field Generator',\n      requiresGenerators: ['prisma-client-js'],\n    };\n  },\n\n  async onGenerate(options: GeneratorOptions) {\n    const { dmmf, generator } = options;\n    const configuredPath = generator.output?.value || './src/generated/prisma-fields.ts';\n    const outputPath = validateOutputPath(configuredPath);\n\n    // Extract models and their fields\n    const modelFieldsMap: Record<string, { fields: string[]; relations: string[] }> = {};\n\n    for (const model of dmmf.datamodel.models) {\n      const scalarFields: string[] = [];\n      const relationFields: string[] = [];\n\n      for (const field of model.fields) {\n        if (field.kind === 'object') {\n          // Relation field\n          relationFields.push(field.name);\n        } else {\n          // Scalar field (string, int, DateTime, etc.)\n          scalarFields.push(field.name);\n        }\n      }\n\n      modelFieldsMap[model.name] = {\n        fields: scalarFields,\n        relations: relationFields,\n      };\n    }\n\n    // Generate TypeScript file content\n    const fileContent = generateTypeScriptFile(modelFieldsMap);\n\n    // Ensure output directory exists (use validated path)\n    const outputDir = dirname(outputPath);\n    safeMkdirSync(outputDir);\n\n    // Write file (use validated path)\n    safeWriteFileSync(outputPath, fileContent);\n\n    console.info(`✅ [Burdenoff] Generated Prisma fields mapping at: ${outputPath}`);\n    console.info(`   Found ${Object.keys(modelFieldsMap).length} models`);\n    console.info(`   Total fields: ${Object.values(modelFieldsMap).reduce((sum, m) => sum + m.fields.length, 0)}`);\n    console.info(\n      `   Total relations: ${Object.values(modelFieldsMap).reduce((sum, m) => sum + m.relations.length, 0)}`\n    );\n  },\n});\n\n/**\n * Generate TypeScript file content\n */\nfunction generateTypeScriptFile(modelFieldsMap: Record<string, { fields: string[]; relations: string[] }>): string {\n  const modelCount = Object.keys(modelFieldsMap).length;\n  const totalFields = Object.values(modelFieldsMap).reduce((sum, m) => sum + m.fields.length, 0);\n  const totalRelations = Object.values(modelFieldsMap).reduce((sum, m) => sum + m.relations.length, 0);\n\n  return `/**\n * Auto-generated Prisma Model Fields\n *\n * This file is automatically generated by @burdenoff/be-sdk Prisma Field Generator\n * DO NOT EDIT MANUALLY - Changes will be overwritten on next generation\n *\n * Generated at: ${new Date().toISOString()}\n * Total models: ${modelCount}\n * Total scalar fields: ${totalFields}\n * Total relation fields: ${totalRelations}\n *\n * @packageDocumentation\n */\n\n/**\n * Type definition for model fields mapping\n */\nexport type ModelFieldsMap = Record<\n  string,\n  {\n    /** Scalar fields (string, number, Date, etc.) */\n    fields: string[];\n    /** Relation fields (references to other models) */\n    relations: string[];\n  }\n>;\n\n/**\n * Mapping of all Prisma models to their fields\n *\n * This mapping is generated at build time from your Prisma schema\n * and contains all models with their scalar and relation fields.\n */\nexport const modelFields: ModelFieldsMap = ${JSON.stringify(modelFieldsMap, null, 2)} as const;\n\n/**\n * Get all scalar fields for a model\n *\n * @param modelName - Name of the Prisma model\n * @param includeRelations - Whether to include relation fields (default: false)\n * @returns Array of field names\n * @throws Error if model is not found\n *\n * @example\n * \\`\\`\\`typescript\n * const userFields = getModelFields('User');\n * // Returns: ['id', 'email', 'name', 'createdAt', 'updatedAt']\n *\n * const userFieldsWithRelations = getModelFields('User', true);\n * // Returns: ['id', 'email', 'name', 'createdAt', 'updatedAt', 'posts', 'profile']\n * \\`\\`\\`\n */\nexport function getModelFields(modelName: string, includeRelations = false): string[] {\n  const model = modelFields[modelName];\n  if (!model) {\n    const available = Object.keys(modelFields).join(', ');\n    throw new Error(\n      \\`Model \"\\${modelName}\" not found in generated fields. Available models: \\${available}\\`\n    );\n  }\n\n  return includeRelations ? [...model.fields, ...model.relations] : model.fields;\n}\n\n/**\n * Get all model names\n *\n * @returns Array of all available model names\n *\n * @example\n * \\`\\`\\`typescript\n * const models = getAllModelNames();\n * // Returns: ['User', 'Post', 'Comment', 'Tag', ...]\n * \\`\\`\\`\n */\nexport function getAllModelNames(): string[] {\n  return Object.keys(modelFields);\n}\n\n/**\n * Check if a model exists in the schema\n *\n * @param modelName - Name of the model to check\n * @returns True if model exists, false otherwise\n *\n * @example\n * \\`\\`\\`typescript\n * if (hasModel('User')) {\n *   const fields = getModelFields('User');\n * }\n * \\`\\`\\`\n */\nexport function hasModel(modelName: string): boolean {\n  return modelName in modelFields;\n}\n\n/**\n * Get only scalar fields (excludes relations)\n *\n * @param modelName - Name of the Prisma model\n * @returns Array of scalar field names\n */\nexport function getScalarFields(modelName: string): string[] {\n  return getModelFields(modelName, false);\n}\n\n/**\n * Get only relation fields\n *\n * @param modelName - Name of the Prisma model\n * @returns Array of relation field names\n */\nexport function getRelationFields(modelName: string): string[] {\n  const model = modelFields[modelName];\n  if (!model) {\n    throw new Error(\\`Model \"\\${modelName}\" not found\\`);\n  }\n  return model.relations;\n}\n\n/**\n * Default export for convenience\n */\nexport default modelFields;\n`;\n}\n"]}

package/dist/prisma/index.d.ts

@@ -0,0 +1,5 @@
+export { C as ContextFilterInput, D as DatabaseClient, a as DatabaseClientConfig, F as FieldExtractionOptions, b as FieldExtractionResult, I as InputJsonValue, J as JsonValue, M as ModelFieldsMap, O as OperationContext, P as PrismaJsonFilter, W as WorkspaceContext, c as WorkspaceExtensionConfig, d as addWorkspaceExtension, e as buildContextWhereClause, f as buildContextWhereConditions, g as checkDatabaseHealth, h as contextMatches, j as createContextFromSDK, k as createDatabaseClient, l as createDatabaseClientFromEnv, m as extractFieldsFromModel, n as getAllModelNames, o as getDatabaseManager, p as getDatabaseProductName, q as getDatabaseStats, r as getDatabaseVersion, s as getDb, t as getModelFields, u as getWorkspaceContext, v as hasModel, w as initializeDatabase, x as initializeDatabaseWithConfig, y as injectWhereWorkspaceId, z as isDatabaseInitialized, A as loadGeneratedFields, B as mergeContext, E as parseContext, G as resetDatabaseManager, H as setWorkspaceContext, K as testConnection, L as toContextJson, N as withWorkspaceContext, Q as withWorkspaceContextSync } from '../index-Dtf6FBaD.js';
+export { C as ConnectionState, d as DatabaseHealth, D as DatabaseReturnType, P as PrismaClientBase, c as PrismaClientConfig, a as PrismaClientConstructorOptions, b as PrismaClientWrapper, e as PrismaEvent, f as PrismaLogDefinition, g as PrismaLogEvent, h as PrismaLogLevel, i as PrismaQueryEvent, j as PrismaTransactionOptions, k as configurePrismaLogging, l as createConnectionPool, m as createPrismaAdapter, n as createPrismaClient } from '../client-CSjIrYKS.js';
+import '../prisma-extension-krXnYnrN.js';
+import '@prisma/adapter-pg';
+import 'pg';

package/dist/prisma/index.js

@@ -0,0 +1,12 @@
+export { PrismaClientWrapper, buildContextWhereClause, buildContextWhereConditions, checkDatabaseHealth, configurePrismaLogging, contextMatches, createConnectionPool, createContextFromSDK, createDatabaseClient, createDatabaseClientFromEnv, createPrismaAdapter, createPrismaClient, extractFieldsFromModel, getAllModelNames, getDatabaseManager, getDatabaseProductName, getDatabaseStats, getDatabaseVersion, getDb, getModelFields, hasModel, initializeDatabase, initializeDatabaseWithConfig, isDatabaseInitialized, loadGeneratedFields, mergeContext, parseContext, resetDatabaseManager, testConnection, toContextJson } from '../chunk-2SD5L2F2.js';
+export { addWorkspaceExtension, getWorkspaceContext, injectWhereWorkspaceId, setWorkspaceContext, withWorkspaceContext, withWorkspaceContextSync } from '../chunk-GTEMQXCA.js';
+import '../chunk-TKBD2ONF.js';
+import '../chunk-ELLX3K54.js';
+import '../chunk-3O2RQOPV.js';
+import '../chunk-L7ZMN2FJ.js';
+import '../chunk-OVSYMNCI.js';
+import '../chunk-NGMEI42S.js';
+import '../chunk-CBZNP6RF.js';
+import '../chunk-XE4OXN2W.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/prisma/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/prisma-extension-krXnYnrN.d.ts

@@ -0,0 +1,30 @@
+type EntityEventType = 'entity.created' | 'entity.updated' | 'entity.deleted' | 'relationship.created' | 'relationship.deleted';
+interface EntityEventRbacMetadata {
+    resourceTypeName: string;
+    name?: string;
+    identifier?: string;
+    parentResourceIdentifier?: string;
+    createResource?: boolean;
+}
+interface GraphEventEmitter {
+    publishEntityEvent(eventType: EntityEventType, entity: {
+        id: string;
+        type: string;
+        data: Record<string, unknown>;
+    }, context: {
+        productName: string;
+        organizationId: string;
+        actorId?: string;
+        workspaceId?: string;
+    }, rbac?: EntityEventRbacMetadata): Promise<void>;
+}
+interface GraphMiddlewareConfig {
+    enabled: boolean;
+    productName: string;
+    eventEmitter: GraphEventEmitter;
+    entityTypes?: string[];
+    monitoredOperations?: Array<'create' | 'update' | 'delete' | 'deleteMany' | 'updateMany'>;
+}
+declare function addGraphExtension<T>(baseClient: T, config: GraphMiddlewareConfig): T;
+
+export { type EntityEventType as E, type GraphEventEmitter as G, type GraphMiddlewareConfig as a, addGraphExtension as b };

package/dist/rbac/index.d.ts

@@ -0,0 +1,116 @@
+import { B as BurdenoffGraphQLClient } from '../graphql-BAVrUgBF.js';
+import { S as SDKContext } from '../index-CHbVw5M7.js';
+import { Plugin } from '@envelop/core';
+import { S as ServiceLayer } from '../layer-DDip18KY.js';
+import 'graphql-request';
+
+type ActorType = 'USER' | 'BOT' | 'INTEGRATION' | 'DELEGATED_AGENT';
+type RBACLayer = 'wspace' | 'global';
+interface RBACDirectiveConfig {
+    rbacServiceUrl: string;
+    layer?: RBACLayer;
+    enableCaching?: boolean;
+    cacheTTL?: number;
+    cacheMaxSize?: number;
+    timeout?: number;
+    failClosed?: boolean;
+    resourceResolver?: (identifier: string, resourceType?: string) => Promise<string | null>;
+    skipRbac?: boolean;
+}
+interface CheckPermissionResult {
+    hasPermission: boolean;
+    reason?: string;
+}
+declare class RBACClient {
+    private client;
+    private cache?;
+    private config;
+    constructor(config: RBACDirectiveConfig);
+    private parsePermission;
+    checkPermission(actorId: string, actorType: ActorType, scopeId: string, permission: string, resourceId?: string): Promise<CheckPermissionResult>;
+    clearCache(): void;
+    invalidateForActor(actorId: string): number;
+    getLayer(): RBACLayer;
+}
+declare function createRBACDirective(config: RBACDirectiveConfig): Plugin;
+
+interface LayerAwareRBACConfig extends Omit<RBACDirectiveConfig, 'rbacServiceUrl' | 'layer'> {
+    rbacServiceUrl?: string;
+}
+declare function createRBACDirectiveForLayer(layer: ServiceLayer, config?: LayerAwareRBACConfig): Plugin;
+declare function createRBACDirectiveFromEnv(serviceName: string, config?: LayerAwareRBACConfig): Plugin;
+
+type PBACActorType = 'USER' | 'BOT' | 'INTEGRATION' | 'DELEGATED_AGENT';
+type PBACPermissionLevel = 'ADMIN' | 'EDITOR' | 'VIEWER' | 'NONE';
+interface CheckPermissionOptions {
+    userId: string;
+    action: string;
+    resourceType: string;
+    resourceId?: string;
+    workspaceId?: string;
+    actorType?: PBACActorType;
+}
+interface EffectivePermissionEntry {
+    resourceType: string;
+    level: PBACPermissionLevel;
+    allowedActions: string[];
+    source: string;
+}
+interface RoleDefaultPermission {
+    resourceType: string;
+    level: PBACPermissionLevel;
+}
+interface Role {
+    id: string;
+    name: string;
+    description?: string;
+    defaultPermissions?: RoleDefaultPermission[];
+}
+interface Permission {
+    id: string;
+    action: string;
+    resourceType: string;
+    description?: string;
+}
+declare class RBACModule {
+    private client;
+    private context;
+    constructor(client: BurdenoffGraphQLClient, context: SDKContext);
+    checkPermission(options: CheckPermissionOptions): Promise<boolean>;
+    requirePermission(options: CheckPermissionOptions): Promise<void>;
+    getUserRoles(userId: string, workspaceId: string): Promise<Role[]>;
+    assignRoleToUser(userId: string, roleId: string, workspaceId: string, actorType?: 'USER' | 'BOT' | 'INTEGRATION' | 'DELEGATED_AGENT'): Promise<boolean>;
+    removeRoleFromUser(userId: string, roleId: string, workspaceId: string): Promise<boolean>;
+    createRole(name: string, description: string, defaultPermissions: RoleDefaultPermission[] | string[], workspaceId: string): Promise<Role>;
+    getAvailablePermissions(): Promise<Permission[]>;
+    checkMultiplePermissions(checks: CheckPermissionOptions[]): Promise<Array<{
+        allowed: boolean;
+        reason?: string;
+    }>>;
+    getEffectivePermissions(userId: string, workspaceId: string, actorType?: 'USER' | 'BOT' | 'INTEGRATION' | 'DELEGATED_AGENT'): Promise<{
+        actorId: string;
+        scopeId: string;
+        permissions: EffectivePermissionEntry[];
+    }>;
+    initializeWorkspaceRoles(workspaceId: string, ownerId: string): Promise<{
+        success: boolean;
+        rolesCreated: number;
+        roleNames: string[];
+        ownerAssigned: boolean;
+        message: string;
+    }>;
+    updateRole(roleId: string, updates: {
+        name?: string;
+        description?: string;
+        priority?: number;
+    }, workspaceId: string): Promise<Role>;
+    deleteRole(roleId: string, workspaceId: string, reassignToRoleId?: string): Promise<boolean>;
+    listRoles(workspaceId: string, options?: {
+        includeSystem?: boolean;
+        limit?: number;
+        offset?: number;
+    }): Promise<Role[]>;
+    getRole(roleId: string, workspaceId: string): Promise<Role | null>;
+}
+
+export { type CheckPermissionOptions, type EffectivePermissionEntry, type LayerAwareRBACConfig, type PBACActorType, type PBACPermissionLevel, type Permission, RBACClient, type RBACDirectiveConfig, RBACModule, type Role, type RoleDefaultPermission, createRBACDirective, createRBACDirectiveForLayer, createRBACDirectiveFromEnv };

package/dist/rbac/index.js

@@ -0,0 +1,7 @@
+export { RBACClient, RBACModule, createRBACDirective, createRBACDirectiveForLayer, createRBACDirectiveFromEnv } from '../chunk-J26YGR2U.js';
+import '../chunk-SAG6ZYWQ.js';
+import '../chunk-NGMEI42S.js';
+import '../chunk-CBZNP6RF.js';
+import '../chunk-XE4OXN2W.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/rbac/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/sdk-THO3IWEE.js

@@ -0,0 +1,136 @@
+import { __name } from './chunk-XE4OXN2W.js';
+
+// src/telemetry/sdk.ts
+var isThenable = /* @__PURE__ */ __name((value) => {
+  return typeof value === "object" && value !== null && typeof value.then === "function";
+}, "isThenable");
+var asyncDisposeMetricReader = /* @__PURE__ */ __name(async (metricReaderCandidate) => {
+  const shutdown = metricReaderCandidate.shutdown;
+  if (typeof shutdown === "function") {
+    const result = shutdown.call(metricReaderCandidate);
+    if (isThenable(result)) await result;
+  }
+}, "asyncDisposeMetricReader");
+async function createOtelSdk(cfg) {
+  const sdkNodeMod = "@opentelemetry/sdk-node";
+  const sdkMod = await import(sdkNodeMod);
+  const resourcesMod = "@opentelemetry/resources";
+  const resources = await import(resourcesMod);
+  const semMod = "@opentelemetry/semantic-conventions";
+  const sem = await import(semMod);
+  const traceExpMod = "@opentelemetry/exporter-trace-otlp-http";
+  const traceExp = await import(traceExpMod);
+  let metricsExp;
+  try {
+    const metricsExpMod = "@opentelemetry/exporter-metrics-otlp-http";
+    metricsExp = await import(metricsExpMod);
+  } catch {
+    metricsExp = void 0;
+  }
+  let metricReader;
+  let metricsEnabled = false;
+  let metricsDropReason;
+  if (metricsExp?.OTLPMetricExporter) {
+    try {
+      const metricsSdkMod = "@opentelemetry/sdk-metrics";
+      const metricsSdk = await import(metricsSdkMod);
+      const candidate = new metricsSdk.PeriodicExportingMetricReader({
+        exporter: new metricsExp.OTLPMetricExporter({
+          url: `${cfg.otlpEndpoint.replace(/\/$/, "")}/v1/metrics`
+        })
+      });
+      const setProducer = candidate.setMetricProducer;
+      if (typeof setProducer === "function") {
+        metricReader = candidate;
+        metricsEnabled = true;
+      } else {
+        metricsDropReason = "setMetricProducer is not a function on PeriodicExportingMetricReader; skipping metrics path";
+        await asyncDisposeMetricReader(candidate);
+        metricReader = void 0;
+      }
+    } catch {
+      if (metricsDropReason === void 0) {
+        metricsDropReason = "metric reader construction or compatibility check failed";
+      }
+      metricReader = void 0;
+    }
+  }
+  let sampler;
+  try {
+    const traceBaseMod = "@opentelemetry/sdk-trace-base";
+    const traceBase = await import(traceBaseMod);
+    sampler = new traceBase.ParentBasedSampler({
+      root: new traceBase.TraceIdRatioBasedSampler(Math.min(1, Math.max(0, cfg.sampleRatio)))
+    });
+  } catch {
+    sampler = void 0;
+  }
+  let autoInstrumentations;
+  try {
+    const autoMod = "@opentelemetry/auto-instrumentations-node";
+    const auto = await import(autoMod);
+    autoInstrumentations = auto.getNodeAutoInstrumentations({
+      "@opentelemetry/instrumentation-fs": {
+        enabled: false
+      }
+    });
+  } catch {
+    autoInstrumentations = void 0;
+  }
+  const serviceNamespaceByBoundary = {
+    wspace: "workspaces",
+    global: "tenant",
+    gateway: "gateways"
+  };
+  const resourceAttributes = {
+    [sem["SEMRESATTRS_SERVICE_NAME"] ?? "service.name"]: cfg.serviceName,
+    [sem["SEMRESATTRS_SERVICE_VERSION"] ?? "service.version"]: cfg.serviceVersion,
+    [sem["SEMRESATTRS_SERVICE_NAMESPACE"] ?? "service.namespace"]: serviceNamespaceByBoundary[cfg.boundary],
+    [sem["SEMRESATTRS_DEPLOYMENT_ENVIRONMENT"] ?? "deployment.environment"]: cfg.env,
+    "burdenoff.boundary": cfg.boundary
+  };
+  if (cfg.module) resourceAttributes["burdenoff.module"] = cfg.module;
+  const serviceInstanceId = process.env["POD_NAME"] ?? process.env["HOSTNAME"];
+  if (serviceInstanceId) resourceAttributes["service.instance.id"] = serviceInstanceId;
+  const clusterName = process.env["CLUSTER_NAME"];
+  if (clusterName) {
+    resourceAttributes["cluster"] = clusterName;
+    resourceAttributes["k8s.cluster.name"] = clusterName;
+  }
+  const resource = resources.resourceFromAttributes(resourceAttributes);
+  const traceExporter = new traceExp.OTLPTraceExporter({
+    url: `${cfg.otlpEndpoint.replace(/\/$/, "")}/v1/traces`
+  });
+  const nodeSdk = new sdkMod.NodeSDK({
+    resource,
+    traceExporter,
+    ...metricReader ? {
+      metricReader
+    } : {},
+    ...sampler ? {
+      sampler
+    } : {},
+    ...autoInstrumentations ? {
+      instrumentations: autoInstrumentations
+    } : {}
+  });
+  const startResult = nodeSdk.start();
+  if (isThenable(startResult)) {
+    await startResult;
+  }
+  try {
+    const otelApiMod = "@opentelemetry/api";
+    globalThis.__otelApi = await import(otelApiMod);
+  } catch {
+  }
+  return {
+    shutdown: /* @__PURE__ */ __name(async () => nodeSdk.shutdown(), "shutdown"),
+    metricsEnabled,
+    metricsDropReason
+  };
+}
+__name(createOtelSdk, "createOtelSdk");
+
+export { createOtelSdk };
+//# sourceMappingURL=sdk-THO3IWEE.js.map
+//# sourceMappingURL=sdk-THO3IWEE.js.map