@sochdb/sochdb 0.4.2 → 0.4.4

package/dist/cjs/policy/index.js

@@ -0,0 +1,26 @@
+"use strict";
+/**
+ * Policy Service Module
+ *
+ * Policy-based access control and namespace governance for SochDB.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolicyService = void 0;
+__exportStar(require("./types"), exports);
+var service_1 = require("./service");
+Object.defineProperty(exports, "PolicyService", { enumerable: true, get: function () { return service_1.PolicyService; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcG9saWN5L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQTs7OztHQUlHOzs7Ozs7Ozs7Ozs7Ozs7OztBQUVILDBDQUF3QjtBQUN4QixxQ0FBMEM7QUFBakMsd0dBQUEsYUFBYSxPQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBQb2xpY3kgU2VydmljZSBNb2R1bGVcbiAqIFxuICogUG9saWN5LWJhc2VkIGFjY2VzcyBjb250cm9sIGFuZCBuYW1lc3BhY2UgZ292ZXJuYW5jZSBmb3IgU29jaERCLlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vdHlwZXMnO1xuZXhwb3J0IHsgUG9saWN5U2VydmljZSB9IGZyb20gJy4vc2VydmljZSc7XG4iXX0=

package/dist/cjs/policy/service.js

@@ -0,0 +1,394 @@
+"use strict";
+/**
+ * Policy Service Implementation
+ *
+ * Policy-based access control and namespace governance for SochDB.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolicyService = void 0;
+/**
+ * Policy Service for access control and governance
+ *
+ * @example
+ * ```typescript
+ * import { EmbeddedDatabase, PolicyService } from '@sochdb/sochdb';
+ *
+ * const db = EmbeddedDatabase.open('./mydb');
+ * const policy = new PolicyService(db);
+ *
+ * // Create a namespace policy
+ * await policy.createNamespacePolicy({
+ *   namespace: 'tenant_123',
+ *   rules: [{
+ *     id: 'read_only',
+ *     name: 'Read Only Access',
+ *     effect: 'allow',
+ *     principals: ['user:*'],
+ *     resources: ['collection:*'],
+ *     actions: ['read', 'search']
+ *   }],
+ *   defaultEffect: 'deny'
+ * });
+ *
+ * // Evaluate access
+ * const result = await policy.evaluate({
+ *   principal: 'user:alice',
+ *   action: 'read',
+ *   resource: 'collection:documents'
+ * });
+ * ```
+ */
+class PolicyService {
+    constructor(db, options) {
+        this.cache = new Map();
+        this.auditEnabled = true;
+        this.db = db;
+        this.prefix = Buffer.from('_policy:');
+        this.auditEnabled = options?.enableAudit ?? true;
+    }
+    /**
+     * Create a namespace policy
+     */
+    async createNamespacePolicy(policy) {
+        const key = this.policyKey(policy.namespace);
+        const data = {
+            ...policy,
+            createdAt: Date.now(),
+            updatedAt: Date.now(),
+        };
+        await this.db.put(key, Buffer.from(JSON.stringify(data)));
+        this.cache.set(policy.namespace, policy);
+    }
+    /**
+     * Get a namespace policy
+     */
+    async getNamespacePolicy(namespace) {
+        // Check cache first
+        if (this.cache.has(namespace)) {
+            return this.cache.get(namespace);
+        }
+        const key = this.policyKey(namespace);
+        const value = await this.db.get(key);
+        if (!value) {
+            return null;
+        }
+        const policy = JSON.parse(value.toString());
+        this.cache.set(namespace, policy);
+        return policy;
+    }
+    /**
+     * Update a namespace policy
+     */
+    async updateNamespacePolicy(namespace, updates) {
+        const existing = await this.getNamespacePolicy(namespace);
+        if (!existing) {
+            throw new Error(`Policy not found for namespace: ${namespace}`);
+        }
+        const updated = {
+            ...existing,
+            ...updates,
+            namespace, // Ensure namespace doesn't change
+            updatedAt: Date.now(),
+        };
+        const key = this.policyKey(namespace);
+        await this.db.put(key, Buffer.from(JSON.stringify(updated)));
+        this.cache.set(namespace, updated);
+    }
+    /**
+     * Delete a namespace policy
+     */
+    async deleteNamespacePolicy(namespace) {
+        const key = this.policyKey(namespace);
+        await this.db.delete(key);
+        this.cache.delete(namespace);
+        return true;
+    }
+    /**
+     * Add a rule to a namespace policy
+     */
+    async addRule(namespace, rule) {
+        const policy = await this.getNamespacePolicy(namespace);
+        if (!policy) {
+            throw new Error(`Policy not found for namespace: ${namespace}`);
+        }
+        // Check for duplicate rule ID
+        if (policy.rules.some(r => r.id === rule.id)) {
+            throw new Error(`Rule with id '${rule.id}' already exists`);
+        }
+        policy.rules.push(rule);
+        await this.updateNamespacePolicy(namespace, { rules: policy.rules });
+    }
+    /**
+     * Remove a rule from a namespace policy
+     */
+    async removeRule(namespace, ruleId) {
+        const policy = await this.getNamespacePolicy(namespace);
+        if (!policy) {
+            return false;
+        }
+        const index = policy.rules.findIndex(r => r.id === ruleId);
+        if (index === -1) {
+            return false;
+        }
+        policy.rules.splice(index, 1);
+        await this.updateNamespacePolicy(namespace, { rules: policy.rules });
+        return true;
+    }
+    /**
+     * Evaluate a policy request
+     */
+    async evaluate(request) {
+        const startTime = Date.now();
+        // Extract namespace from resource
+        const namespace = this.extractNamespace(request.resource);
+        const policy = namespace ? await this.getNamespacePolicy(namespace) : null;
+        let result;
+        if (!policy) {
+            // No policy = allow by default
+            result = {
+                allowed: true,
+                reason: 'No policy defined',
+                evaluationTime: Date.now() - startTime,
+            };
+        }
+        else {
+            // Evaluate rules in priority order
+            const sortedRules = [...policy.rules].sort((a, b) => (a.priority || 0) - (b.priority || 0));
+            let matchedRule;
+            for (const rule of sortedRules) {
+                if (this.matchesRule(request, rule)) {
+                    matchedRule = rule;
+                    break;
+                }
+            }
+            if (matchedRule) {
+                result = {
+                    allowed: matchedRule.effect === 'allow',
+                    matchedRule,
+                    reason: `Matched rule: ${matchedRule.name}`,
+                    evaluationTime: Date.now() - startTime,
+                };
+            }
+            else {
+                result = {
+                    allowed: policy.defaultEffect === 'allow',
+                    reason: `Default effect: ${policy.defaultEffect}`,
+                    evaluationTime: Date.now() - startTime,
+                };
+            }
+        }
+        // Log audit entry
+        if (this.auditEnabled) {
+            await this.logAudit(request, result);
+        }
+        return result;
+    }
+    /**
+     * Grant namespace access to a principal
+     */
+    async grantAccess(grant) {
+        const key = this.grantKey(grant.namespace, grant.principal);
+        const data = {
+            ...grant,
+            grantedAt: Date.now(),
+        };
+        await this.db.put(key, Buffer.from(JSON.stringify(data)));
+    }
+    /**
+     * Revoke namespace access from a principal
+     */
+    async revokeAccess(namespace, principal) {
+        const key = this.grantKey(namespace, principal);
+        await this.db.delete(key);
+        return true;
+    }
+    /**
+     * Check if principal has permission
+     */
+    async hasPermission(namespace, principal, permission) {
+        const key = this.grantKey(namespace, principal);
+        const value = await this.db.get(key);
+        if (!value) {
+            return false;
+        }
+        const grant = JSON.parse(value.toString());
+        // Check expiration
+        if (grant.expiresAt && Date.now() > grant.expiresAt) {
+            return false;
+        }
+        // Admin has all permissions
+        if (grant.permissions.includes('admin')) {
+            return true;
+        }
+        return grant.permissions.includes(permission);
+    }
+    /**
+     * List all grants for a namespace
+     */
+    async listGrants(namespace) {
+        const grants = [];
+        const prefix = Buffer.from(`_grant:${namespace}:`);
+        try {
+            for await (const [_, valueBuffer] of this.db.scanPrefix(prefix)) {
+                const grant = JSON.parse(valueBuffer.toString());
+                grants.push(grant);
+            }
+        }
+        catch (error) {
+            // Ignore scan errors
+        }
+        return grants;
+    }
+    /**
+     * Get audit log entries
+     */
+    async getAuditLog(options) {
+        const entries = [];
+        const prefix = Buffer.from('_audit:');
+        const limit = options?.limit || 100;
+        try {
+            for await (const [_, valueBuffer] of this.db.scanPrefix(prefix)) {
+                const entry = JSON.parse(valueBuffer.toString());
+                // Apply filters
+                if (options?.namespace && !entry.resource.includes(options.namespace)) {
+                    continue;
+                }
+                if (options?.principal && entry.principal !== options.principal) {
+                    continue;
+                }
+                if (options?.action && entry.action !== options.action) {
+                    continue;
+                }
+                if (options?.since && entry.timestamp < options.since) {
+                    continue;
+                }
+                entries.push(entry);
+                if (entries.length >= limit) {
+                    break;
+                }
+            }
+        }
+        catch (error) {
+            // Ignore scan errors
+        }
+        // Sort by timestamp descending
+        return entries.sort((a, b) => b.timestamp - a.timestamp);
+    }
+    /**
+     * Clear policy cache
+     */
+    clearCache() {
+        this.cache.clear();
+    }
+    // Private methods
+    policyKey(namespace) {
+        return Buffer.concat([this.prefix, Buffer.from(`namespace:${namespace}`)]);
+    }
+    grantKey(namespace, principal) {
+        return Buffer.from(`_grant:${namespace}:${principal}`);
+    }
+    extractNamespace(resource) {
+        // Extract namespace from resource like "namespace:tenant_123:collection:docs"
+        const parts = resource.split(':');
+        if (parts.length >= 2 && parts[0] === 'namespace') {
+            return parts[1];
+        }
+        // Try to extract from collection format "collection:tenant_123:docs"
+        if (parts.length >= 2 && parts[0] === 'collection') {
+            return parts[1];
+        }
+        return null;
+    }
+    matchesRule(request, rule) {
+        // Check principals
+        if (!this.matchesPatterns(request.principal, rule.principals)) {
+            return false;
+        }
+        // Check resources
+        if (!this.matchesPatterns(request.resource, rule.resources)) {
+            return false;
+        }
+        // Check actions
+        if (!this.matchesPatterns(request.action, rule.actions)) {
+            return false;
+        }
+        // Check conditions
+        if (rule.conditions && rule.conditions.length > 0) {
+            for (const condition of rule.conditions) {
+                if (!this.evaluateCondition(condition, request.context)) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    matchesPatterns(value, patterns) {
+        for (const pattern of patterns) {
+            if (this.matchesPattern(value, pattern)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    matchesPattern(value, pattern) {
+        if (pattern === '*') {
+            return true;
+        }
+        if (pattern.endsWith('*')) {
+            return value.startsWith(pattern.slice(0, -1));
+        }
+        if (pattern.startsWith('*')) {
+            return value.endsWith(pattern.slice(1));
+        }
+        return value === pattern;
+    }
+    evaluateCondition(condition, context) {
+        if (!context) {
+            return false;
+        }
+        const value = context[condition.key];
+        if (value === undefined) {
+            return false;
+        }
+        switch (condition.operator) {
+            case 'equals':
+                return value === condition.value;
+            case 'not_equals':
+                return value !== condition.value;
+            case 'contains':
+                return String(value).includes(String(condition.value));
+            case 'starts_with':
+                return String(value).startsWith(String(condition.value));
+            case 'ends_with':
+                return String(value).endsWith(String(condition.value));
+            case 'in':
+                return Array.isArray(condition.value) && condition.value.includes(value);
+            case 'not_in':
+                return Array.isArray(condition.value) && !condition.value.includes(value);
+            case 'between':
+                if (Array.isArray(condition.value) && condition.value.length === 2) {
+                    return value >= condition.value[0] && value <= condition.value[1];
+                }
+                return false;
+            default:
+                return false;
+        }
+    }
+    async logAudit(request, result) {
+        const entry = {
+            id: `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+            timestamp: Date.now(),
+            principal: request.principal,
+            action: request.action,
+            resource: request.resource,
+            decision: result.allowed ? 'allow' : 'deny',
+            matchedRule: result.matchedRule?.id,
+            reason: result.reason,
+            context: request.context,
+        };
+        const key = Buffer.from(`_audit:${entry.timestamp}:${entry.id}`);
+        await this.db.put(key, Buffer.from(JSON.stringify(entry)));
+    }
+}
+exports.PolicyService = PolicyService;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"service.js","sourceRoot":"","sources":["../../../src/policy/service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Policy Service Implementation\n * \n * Policy-based access control and namespace governance for SochDB.\n */\n\nimport { EmbeddedDatabase } from '../embedded';\nimport {\n  PolicyRule,\n  PolicyCondition,\n  PolicyEvaluation,\n  NamespacePolicy,\n  NamespaceGrant,\n  NamespacePermission,\n  PolicyRequest,\n  PolicySet,\n  PolicyAuditEntry,\n} from './types';\n\n/**\n * Policy Service for access control and governance\n * \n * @example\n * ```typescript\n * import { EmbeddedDatabase, PolicyService } from '@sochdb/sochdb';\n * \n * const db = EmbeddedDatabase.open('./mydb');\n * const policy = new PolicyService(db);\n * \n * // Create a namespace policy\n * await policy.createNamespacePolicy({\n *   namespace: 'tenant_123',\n *   rules: [{\n *     id: 'read_only',\n *     name: 'Read Only Access',\n *     effect: 'allow',\n *     principals: ['user:*'],\n *     resources: ['collection:*'],\n *     actions: ['read', 'search']\n *   }],\n *   defaultEffect: 'deny'\n * });\n * \n * // Evaluate access\n * const result = await policy.evaluate({\n *   principal: 'user:alice',\n *   action: 'read',\n *   resource: 'collection:documents'\n * });\n * ```\n */\nexport class PolicyService {\n  private db: EmbeddedDatabase;\n  private prefix: Buffer;\n  private cache: Map<string, NamespacePolicy> = new Map();\n  private auditEnabled = true;\n\n  constructor(db: EmbeddedDatabase, options?: { enableAudit?: boolean }) {\n    this.db = db;\n    this.prefix = Buffer.from('_policy:');\n    this.auditEnabled = options?.enableAudit ?? true;\n  }\n\n  /**\n   * Create a namespace policy\n   */\n  async createNamespacePolicy(policy: NamespacePolicy): Promise<void> {\n    const key = this.policyKey(policy.namespace);\n    const data = {\n      ...policy,\n      createdAt: Date.now(),\n      updatedAt: Date.now(),\n    };\n    \n    await this.db.put(key, Buffer.from(JSON.stringify(data)));\n    this.cache.set(policy.namespace, policy);\n  }\n\n  /**\n   * Get a namespace policy\n   */\n  async getNamespacePolicy(namespace: string): Promise<NamespacePolicy | null> {\n    // Check cache first\n    if (this.cache.has(namespace)) {\n      return this.cache.get(namespace)!;\n    }\n\n    const key = this.policyKey(namespace);\n    const value = await this.db.get(key);\n    \n    if (!value) {\n      return null;\n    }\n\n    const policy = JSON.parse(value.toString()) as NamespacePolicy;\n    this.cache.set(namespace, policy);\n    return policy;\n  }\n\n  /**\n   * Update a namespace policy\n   */\n  async updateNamespacePolicy(namespace: string, updates: Partial<NamespacePolicy>): Promise<void> {\n    const existing = await this.getNamespacePolicy(namespace);\n    if (!existing) {\n      throw new Error(`Policy not found for namespace: ${namespace}`);\n    }\n\n    const updated = {\n      ...existing,\n      ...updates,\n      namespace, // Ensure namespace doesn't change\n      updatedAt: Date.now(),\n    };\n\n    const key = this.policyKey(namespace);\n    await this.db.put(key, Buffer.from(JSON.stringify(updated)));\n    this.cache.set(namespace, updated);\n  }\n\n  /**\n   * Delete a namespace policy\n   */\n  async deleteNamespacePolicy(namespace: string): Promise<boolean> {\n    const key = this.policyKey(namespace);\n    await this.db.delete(key);\n    this.cache.delete(namespace);\n    return true;\n  }\n\n  /**\n   * Add a rule to a namespace policy\n   */\n  async addRule(namespace: string, rule: PolicyRule): Promise<void> {\n    const policy = await this.getNamespacePolicy(namespace);\n    if (!policy) {\n      throw new Error(`Policy not found for namespace: ${namespace}`);\n    }\n\n    // Check for duplicate rule ID\n    if (policy.rules.some(r => r.id === rule.id)) {\n      throw new Error(`Rule with id '${rule.id}' already exists`);\n    }\n\n    policy.rules.push(rule);\n    await this.updateNamespacePolicy(namespace, { rules: policy.rules });\n  }\n\n  /**\n   * Remove a rule from a namespace policy\n   */\n  async removeRule(namespace: string, ruleId: string): Promise<boolean> {\n    const policy = await this.getNamespacePolicy(namespace);\n    if (!policy) {\n      return false;\n    }\n\n    const index = policy.rules.findIndex(r => r.id === ruleId);\n    if (index === -1) {\n      return false;\n    }\n\n    policy.rules.splice(index, 1);\n    await this.updateNamespacePolicy(namespace, { rules: policy.rules });\n    return true;\n  }\n\n  /**\n   * Evaluate a policy request\n   */\n  async evaluate(request: PolicyRequest): Promise<PolicyEvaluation> {\n    const startTime = Date.now();\n    \n    // Extract namespace from resource\n    const namespace = this.extractNamespace(request.resource);\n    const policy = namespace ? await this.getNamespacePolicy(namespace) : null;\n\n    let result: PolicyEvaluation;\n\n    if (!policy) {\n      // No policy = allow by default\n      result = {\n        allowed: true,\n        reason: 'No policy defined',\n        evaluationTime: Date.now() - startTime,\n      };\n    } else {\n      // Evaluate rules in priority order\n      const sortedRules = [...policy.rules].sort((a, b) => \n        (a.priority || 0) - (b.priority || 0)\n      );\n\n      let matchedRule: PolicyRule | undefined;\n\n      for (const rule of sortedRules) {\n        if (this.matchesRule(request, rule)) {\n          matchedRule = rule;\n          break;\n        }\n      }\n\n      if (matchedRule) {\n        result = {\n          allowed: matchedRule.effect === 'allow',\n          matchedRule,\n          reason: `Matched rule: ${matchedRule.name}`,\n          evaluationTime: Date.now() - startTime,\n        };\n      } else {\n        result = {\n          allowed: policy.defaultEffect === 'allow',\n          reason: `Default effect: ${policy.defaultEffect}`,\n          evaluationTime: Date.now() - startTime,\n        };\n      }\n    }\n\n    // Log audit entry\n    if (this.auditEnabled) {\n      await this.logAudit(request, result);\n    }\n\n    return result;\n  }\n\n  /**\n   * Grant namespace access to a principal\n   */\n  async grantAccess(grant: NamespaceGrant): Promise<void> {\n    const key = this.grantKey(grant.namespace, grant.principal);\n    const data = {\n      ...grant,\n      grantedAt: Date.now(),\n    };\n    \n    await this.db.put(key, Buffer.from(JSON.stringify(data)));\n  }\n\n  /**\n   * Revoke namespace access from a principal\n   */\n  async revokeAccess(namespace: string, principal: string): Promise<boolean> {\n    const key = this.grantKey(namespace, principal);\n    await this.db.delete(key);\n    return true;\n  }\n\n  /**\n   * Check if principal has permission\n   */\n  async hasPermission(\n    namespace: string,\n    principal: string,\n    permission: NamespacePermission\n  ): Promise<boolean> {\n    const key = this.grantKey(namespace, principal);\n    const value = await this.db.get(key);\n    \n    if (!value) {\n      return false;\n    }\n\n    const grant = JSON.parse(value.toString()) as NamespaceGrant;\n\n    // Check expiration\n    if (grant.expiresAt && Date.now() > grant.expiresAt) {\n      return false;\n    }\n\n    // Admin has all permissions\n    if (grant.permissions.includes('admin')) {\n      return true;\n    }\n\n    return grant.permissions.includes(permission);\n  }\n\n  /**\n   * List all grants for a namespace\n   */\n  async listGrants(namespace: string): Promise<NamespaceGrant[]> {\n    const grants: NamespaceGrant[] = [];\n    const prefix = Buffer.from(`_grant:${namespace}:`);\n\n    try {\n      for await (const [_, valueBuffer] of this.db.scanPrefix(prefix)) {\n        const grant = JSON.parse(valueBuffer.toString()) as NamespaceGrant;\n        grants.push(grant);\n      }\n    } catch (error) {\n      // Ignore scan errors\n    }\n\n    return grants;\n  }\n\n  /**\n   * Get audit log entries\n   */\n  async getAuditLog(options?: {\n    namespace?: string;\n    principal?: string;\n    action?: string;\n    since?: number;\n    limit?: number;\n  }): Promise<PolicyAuditEntry[]> {\n    const entries: PolicyAuditEntry[] = [];\n    const prefix = Buffer.from('_audit:');\n    const limit = options?.limit || 100;\n\n    try {\n      for await (const [_, valueBuffer] of this.db.scanPrefix(prefix)) {\n        const entry = JSON.parse(valueBuffer.toString()) as PolicyAuditEntry;\n        \n        // Apply filters\n        if (options?.namespace && !entry.resource.includes(options.namespace)) {\n          continue;\n        }\n        if (options?.principal && entry.principal !== options.principal) {\n          continue;\n        }\n        if (options?.action && entry.action !== options.action) {\n          continue;\n        }\n        if (options?.since && entry.timestamp < options.since) {\n          continue;\n        }\n\n        entries.push(entry);\n        \n        if (entries.length >= limit) {\n          break;\n        }\n      }\n    } catch (error) {\n      // Ignore scan errors\n    }\n\n    // Sort by timestamp descending\n    return entries.sort((a, b) => b.timestamp - a.timestamp);\n  }\n\n  /**\n   * Clear policy cache\n   */\n  clearCache(): void {\n    this.cache.clear();\n  }\n\n  // Private methods\n\n  private policyKey(namespace: string): Buffer {\n    return Buffer.concat([this.prefix, Buffer.from(`namespace:${namespace}`)]);\n  }\n\n  private grantKey(namespace: string, principal: string): Buffer {\n    return Buffer.from(`_grant:${namespace}:${principal}`);\n  }\n\n  private extractNamespace(resource: string): string | null {\n    // Extract namespace from resource like \"namespace:tenant_123:collection:docs\"\n    const parts = resource.split(':');\n    if (parts.length >= 2 && parts[0] === 'namespace') {\n      return parts[1];\n    }\n    // Try to extract from collection format \"collection:tenant_123:docs\"\n    if (parts.length >= 2 && parts[0] === 'collection') {\n      return parts[1];\n    }\n    return null;\n  }\n\n  private matchesRule(request: PolicyRequest, rule: PolicyRule): boolean {\n    // Check principals\n    if (!this.matchesPatterns(request.principal, rule.principals)) {\n      return false;\n    }\n\n    // Check resources\n    if (!this.matchesPatterns(request.resource, rule.resources)) {\n      return false;\n    }\n\n    // Check actions\n    if (!this.matchesPatterns(request.action, rule.actions)) {\n      return false;\n    }\n\n    // Check conditions\n    if (rule.conditions && rule.conditions.length > 0) {\n      for (const condition of rule.conditions) {\n        if (!this.evaluateCondition(condition, request.context)) {\n          return false;\n        }\n      }\n    }\n\n    return true;\n  }\n\n  private matchesPatterns(value: string, patterns: string[]): boolean {\n    for (const pattern of patterns) {\n      if (this.matchesPattern(value, pattern)) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  private matchesPattern(value: string, pattern: string): boolean {\n    if (pattern === '*') {\n      return true;\n    }\n    \n    if (pattern.endsWith('*')) {\n      return value.startsWith(pattern.slice(0, -1));\n    }\n    \n    if (pattern.startsWith('*')) {\n      return value.endsWith(pattern.slice(1));\n    }\n    \n    return value === pattern;\n  }\n\n  private evaluateCondition(condition: PolicyCondition, context?: Record<string, any>): boolean {\n    if (!context) {\n      return false;\n    }\n\n    const value = context[condition.key];\n    if (value === undefined) {\n      return false;\n    }\n\n    switch (condition.operator) {\n      case 'equals':\n        return value === condition.value;\n      case 'not_equals':\n        return value !== condition.value;\n      case 'contains':\n        return String(value).includes(String(condition.value));\n      case 'starts_with':\n        return String(value).startsWith(String(condition.value));\n      case 'ends_with':\n        return String(value).endsWith(String(condition.value));\n      case 'in':\n        return Array.isArray(condition.value) && condition.value.includes(value);\n      case 'not_in':\n        return Array.isArray(condition.value) && !condition.value.includes(value);\n      case 'between':\n        if (Array.isArray(condition.value) && condition.value.length === 2) {\n          return value >= condition.value[0] && value <= condition.value[1];\n        }\n        return false;\n      default:\n        return false;\n    }\n  }\n\n  private async logAudit(request: PolicyRequest, result: PolicyEvaluation): Promise<void> {\n    const entry: PolicyAuditEntry = {\n      id: `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,\n      timestamp: Date.now(),\n      principal: request.principal,\n      action: request.action,\n      resource: request.resource,\n      decision: result.allowed ? 'allow' : 'deny',\n      matchedRule: result.matchedRule?.id,\n      reason: result.reason,\n      context: request.context,\n    };\n\n    const key = Buffer.from(`_audit:${entry.timestamp}:${entry.id}`);\n    await this.db.put(key, Buffer.from(JSON.stringify(entry)));\n  }\n}\n"]}

package/dist/cjs/policy/types.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * Policy Service Types
+ *
+ * Type definitions for policy-based access control and namespace governance.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,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