@sochdb/sochdb 0.4.2 → 0.4.4

package/dist/esm/policy/service.js

@@ -0,0 +1,396 @@
+"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 {
+    db;
+    prefix;
+    cache = new Map();
+    auditEnabled = true;
+    constructor(db, options) {
+        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/esm/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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

package/dist/types/embedded/database.d.ts

@@ -31,15 +31,80 @@ export declare class EmbeddedDatabase {
     private bindings;
     private closed;
     private path;
+    private concurrent;
+    private _concurrentModeFallback;
     private constructor();
     /**
-     * Open a database at the specified path
+     * Open a database at the specified path in standard mode
+     *
+     * For web applications with multiple processes, use `openConcurrent()` instead.
      *
      * @param path - Path to database directory
      * @param config - Optional configuration
      * @returns EmbeddedDatabase instance
      */
     static open(path: string, config?: EmbeddedDatabaseConfig): EmbeddedDatabase;
+    /**
+     * Open a database in concurrent mode for multi-process web applications
+     *
+     * This mode allows multiple Node.js processes (e.g., PM2 cluster workers,
+     * multiple Express instances) to access the database simultaneously.
+     *
+     * Features:
+     * - Lock-free reads with ~100ns latency
+     * - Multi-reader, single-writer coordination
+     * - Automatic write serialization
+     *
+     * @example
+     * ```typescript
+     * import { EmbeddedDatabase } from '@sochdb/sochdb';
+     * import express from 'express';
+     *
+     * // Open in concurrent mode - multiple workers can access
+     * const db = EmbeddedDatabase.openConcurrent('./web_db');
+     *
+     * const app = express();
+     *
+     * app.get('/user/:id', async (req, res) => {
+     *   // Multiple concurrent requests can read simultaneously
+     *   const data = await db.get(Buffer.from(`user:${req.params.id}`));
+     *   if (!data) {
+     *     res.status(404).json({ error: 'not found' });
+     *     return;
+     *   }
+     *   res.send(data);
+     * });
+     *
+     * app.post('/user/:id', async (req, res) => {
+     *   // Writes are serialized automatically
+     *   await db.put(Buffer.from(`user:${req.params.id}`), req.body);
+     *   res.json({ status: 'ok' });
+     * });
+     *
+     * // Start with PM2 cluster mode:
+     * // pm2 start app.js -i max
+     * app.listen(3000);
+     * ```
+     *
+     * @param path - Path to database directory
+     * @param options - Optional configuration for concurrent mode
+     * @returns EmbeddedDatabase instance in concurrent mode
+     */
+    static openConcurrent(path: string, options?: {
+        fallbackToStandard?: boolean;
+    }): EmbeddedDatabase;
+    /**
+     * Check if database is opened in concurrent mode
+     */
+    get isConcurrent(): boolean;
+    /**
+     * Check if concurrent mode fell back to standard mode
+     */
+    get isConcurrentFallback(): boolean;
+    /**
+     * Check if concurrent mode is available in the native library
+     */
+    static isConcurrentModeAvailable(): boolean;
     /**
      * Put a key-value pair (auto-transaction)
      */

package/dist/types/embedded/database.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"database.d.ts","sourceRoot":"","sources":["../../../src/embedded/database.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAGpD,MAAM,WAAW,sBAAsB;IACnC,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;IACrC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,WAAW,CAAC,EAAE,iBAAiB,GAAG,UAAU,GAAG,gBAAgB,GAAG,aAAa,CAAC;CACnF;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,gBAAgB;IACzB,OAAO,CAAC,MAAM,CAAM;IACpB,OAAO,CAAC,QAAQ,CAAiB;IACjC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,IAAI,CAAS;IAErB,OAAO;IAMP;;;;;;OAMG;IACH,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,sBAAsB,GAAG,gBAAgB;IA4B5E;;OAEG;IACG,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAapD;;OAEG;IACG,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAc9C;;OAEG;IACG,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAaxC;;OAEG;IACG,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAazD;;OAEG;IACG,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAcnD;;OAEG;IACI,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,cAAc,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAenE;;OAEG;IACH,WAAW,IAAI,mBAAmB;IAOlC;;OAEG;IACG,eAAe,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,mBAAmB,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAYlF;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC;IAMnC;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC;QACnB,iBAAiB,EAAE,MAAM,CAAC;QAC1B,YAAY,EAAE,MAAM,CAAC;QACrB,kBAAkB,EAAE,MAAM,CAAC;QAC3B,iBAAiB,EAAE,MAAM,CAAC;QAC1B,iBAAiB,EAAE,MAAM,CAAC;KAC7B,CAAC;IAiBF;;OAEG;IACH,KAAK,IAAI,IAAI;IAOb,OAAO,CAAC,UAAU;IAMlB;;;OAGG;IACH,SAAS,IAAI,GAAG;IAIhB;;;OAGG;IACH,WAAW,IAAI,cAAc;CAGhC"}
+{"version":3,"file":"database.d.ts","sourceRoot":"","sources":["../../../src/embedded/database.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAGpD,MAAM,WAAW,sBAAsB;IACnC,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;IACrC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,WAAW,CAAC,EAAE,iBAAiB,GAAG,UAAU,GAAG,gBAAgB,GAAG,aAAa,CAAC;CACnF;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,gBAAgB;IACzB,OAAO,CAAC,MAAM,CAAM;IACpB,OAAO,CAAC,QAAQ,CAAiB;IACjC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,IAAI,CAAS;IACrB,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,uBAAuB,CAAS;IAExC,OAAO;IAQP;;;;;;;;OAQG;IACH,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,sBAAsB,GAAG,gBAAgB;IA4B5E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6CG;IACH,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,kBAAkB,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,gBAAgB;IAgCjG;;OAEG;IACH,IAAI,YAAY,IAAI,OAAO,CAE1B;IAED;;OAEG;IACH,IAAI,oBAAoB,IAAI,OAAO,CAElC;IAED;;OAEG;IACH,MAAM,CAAC,yBAAyB,IAAI,OAAO;IAI3C;;OAEG;IACG,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAapD;;OAEG;IACG,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAc9C;;OAEG;IACG,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAaxC;;OAEG;IACG,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAazD;;OAEG;IACG,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAcnD;;OAEG;IACI,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,cAAc,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAenE;;OAEG;IACH,WAAW,IAAI,mBAAmB;IAOlC;;OAEG;IACG,eAAe,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,mBAAmB,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAYlF;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC;IAMnC;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC;QACnB,iBAAiB,EAAE,MAAM,CAAC;QAC1B,YAAY,EAAE,MAAM,CAAC;QACrB,kBAAkB,EAAE,MAAM,CAAC;QAC3B,iBAAiB,EAAE,MAAM,CAAC;QAC1B,iBAAiB,EAAE,MAAM,CAAC;KAC7B,CAAC;IAiBF;;OAEG;IACH,KAAK,IAAI,IAAI;IAOb,OAAO,CAAC,UAAU;IAMlB;;;OAGG;IACH,SAAS,IAAI,GAAG;IAIhB;;;OAGG;IACH,WAAW,IAAI,cAAc;CAGhC"}

package/dist/types/embedded/ffi/bindings.d.ts

@@ -1,8 +1,11 @@
 export declare class NativeBindings {
     private static instance;
     private lib;
+    private _concurrentModeAvailable;
     sochdb_open: any;
     sochdb_open_with_config: any;
+    sochdb_open_concurrent: any;
+    sochdb_is_concurrent: any;
     sochdb_close: any;
     sochdb_begin_txn: any;
     sochdb_commit: any;
@@ -20,5 +23,9 @@ export declare class NativeBindings {
     sochdb_free_bytes: any;
     private constructor();
     static getInstance(): NativeBindings;
+    /**
+     * Check if concurrent mode is available in the native library
+     */
+    isConcurrentModeAvailable(): boolean;
 }
 //# sourceMappingURL=bindings.d.ts.map

package/dist/types/embedded/ffi/bindings.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bindings.d.ts","sourceRoot":"","sources":["../../../../src/embedded/ffi/bindings.ts"],"names":[],"mappings":"AAsCA,qBAAa,cAAc;IACvB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAiB;IACxC,OAAO,CAAC,GAAG,CAAM;IAGV,WAAW,EAAE,GAAG,CAAC;IACjB,uBAAuB,EAAE,GAAG,CAAC;IAC7B,YAAY,EAAE,GAAG,CAAC;IAGlB,gBAAgB,EAAE,GAAG,CAAC;IACtB,aAAa,EAAE,GAAG,CAAC;IACnB,YAAY,EAAE,GAAG,CAAC;IAIlB,UAAU,EAAE,GAAG,CAAC;IAEhB,UAAU,EAAE,GAAG,CAAC;IAEhB,aAAa,EAAE,GAAG,CAAC;IAGnB,eAAe,EAAE,GAAG,CAAC;IACrB,eAAe,EAAE,GAAG,CAAC;IAGrB,kBAAkB,EAAE,GAAG,CAAC;IACxB,oBAAoB,EAAE,GAAG,CAAC;IAC1B,qBAAqB,EAAE,GAAG,CAAC;IAG3B,YAAY,EAAE,GAAG,CAAC;IAClB,iBAAiB,EAAE,GAAG,CAAC;IAGvB,iBAAiB,EAAE,GAAG,CAAC;IAE9B,OAAO;WA2CO,WAAW,IAAI,cAAc;CAM9C"}
+{"version":3,"file":"bindings.d.ts","sourceRoot":"","sources":["../../../../src/embedded/ffi/bindings.ts"],"names":[],"mappings":"AAyDA,qBAAa,cAAc;IACvB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAiB;IACxC,OAAO,CAAC,GAAG,CAAM;IACjB,OAAO,CAAC,wBAAwB,CAAS;IAGlC,WAAW,EAAE,GAAG,CAAC;IACjB,uBAAuB,EAAE,GAAG,CAAC;IAC7B,sBAAsB,EAAE,GAAG,CAAC;IAC5B,oBAAoB,EAAE,GAAG,CAAC;IAC1B,YAAY,EAAE,GAAG,CAAC;IAGlB,gBAAgB,EAAE,GAAG,CAAC;IACtB,aAAa,EAAE,GAAG,CAAC;IACnB,YAAY,EAAE,GAAG,CAAC;IAIlB,UAAU,EAAE,GAAG,CAAC;IAEhB,UAAU,EAAE,GAAG,CAAC;IAEhB,aAAa,EAAE,GAAG,CAAC;IAGnB,eAAe,EAAE,GAAG,CAAC;IACrB,eAAe,EAAE,GAAG,CAAC;IAGrB,kBAAkB,EAAE,GAAG,CAAC;IACxB,oBAAoB,EAAE,GAAG,CAAC;IAC1B,qBAAqB,EAAE,GAAG,CAAC;IAG3B,YAAY,EAAE,GAAG,CAAC;IAClB,iBAAiB,EAAE,GAAG,CAAC;IAGvB,iBAAiB,EAAE,GAAG,CAAC;IAE9B,OAAO;WAwDO,WAAW,IAAI,cAAc;IAO3C;;OAEG;IACI,yBAAyB,IAAI,OAAO;CAG9C"}

package/dist/types/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * SochDB Node.js SDK v0.4.2
+ * SochDB Node.js SDK v0.4.4
  *
  * Dual-mode architecture: Embedded (FFI) + Server (gRPC/IPC)
  *
@@ -12,7 +12,12 @@
  *    - No server required - just npm install and run
  *    - Best for: Local development, simple apps
  *
- * 2. Server Mode (gRPC/IPC) - For distributed systems:
+ * 2. Concurrent Mode (FFI) - For multi-process apps:
+ *    - Same FFI bindings with MVCC for concurrent access
+ *    - Multiple Node.js processes can access same database
+ *    - Best for: PM2 cluster, Express workers
+ *
+ * 3. Server Mode (gRPC/IPC) - For distributed systems:
  *    - Thin client connecting to sochdb-grpc server
  *    - Best for: Production, multi-language, scalability
  *
@@ -26,6 +31,15 @@
  * await db.close();
  * ```
  *
+ * @example Concurrent Mode
+ * ```typescript
+ * import { Database } from '@sochdb/sochdb';
+ *
+ * // Multiple processes can access simultaneously
+ * const db = Database.openConcurrent('./mydb');
+ * console.log(`Concurrent: ${db.isConcurrent}`);
+ * ```
+ *
  * @example Server Mode
  * ```typescript
  * import { SochDBClient } from '@sochdb/sochdb';
@@ -35,7 +49,7 @@
  * await client.putKv('key', Buffer.from('value'));
  * ```
  */
-export declare const VERSION = "0.4.2";
+export declare const VERSION = "0.4.4";
 export { EmbeddedDatabase, EmbeddedDatabaseConfig } from './embedded';
 export { EmbeddedTransaction } from './embedded';
 export { HnswIndex, HnswConfig, HnswBindings } from './embedded';
@@ -49,8 +63,12 @@ export { SemanticCache, } from './semantic-cache';
 export type { CacheEntry, CacheHit, CacheStats, } from './semantic-cache';
 export { ContextQueryBuilder, ContextOutputFormat, TruncationStrategy, createContextBuilder, } from './context-builder';
 export type { ContextResult, } from './context-builder';
-export { ExtractionPipeline, Consolidator, HybridRetriever, AllowedSet, NamespacePolicy, } from './memory';
-export type { Entity, Relation, Assertion, RawAssertion, CanonicalFact, ExtractionResult, ExtractionSchema, ConsolidationConfig, RetrievalConfig, RetrievalResult, RetrievalResponse, NamespaceGrant, } from './memory';
+export { ExtractionPipeline, Consolidator, HybridRetriever, AllowedSet, } from './memory';
+export type { Entity, Relation, Assertion, RawAssertion, CanonicalFact, ExtractionResult, ExtractionSchema, ConsolidationConfig, RetrievalConfig, RetrievalResult, RetrievalResponse, } from './memory';
+export { McpServer, McpClient, McpError, MCP_ERROR_CODES, } from './mcp';
+export type { McpTool, McpToolCall, McpToolResult, McpResource, McpResourceContent, McpPrompt, McpPromptArgument, McpPromptMessage, McpServerCapabilities, McpServerConfig, McpClientConfig, McpTransport, } from './mcp';
+export { PolicyService, } from './policy';
+export type { PolicyRule, PolicyCondition, PolicyEvaluation, NamespacePolicy, NamespaceGrant, NamespacePermission, PolicyAction, PolicyRequest, PolicySet, PolicyAuditEntry, } from './policy';
 export { SochDBClient } from './grpc-client';
 export type { SearchResult, Document, GraphNode, GraphEdge, } from './grpc-client';
 export { IpcClient } from './ipc-client';