@fabricorg/platform 0.1.1 → 0.2.0

package/dist/policies/index.cjs

@@ -0,0 +1,48 @@
+'use strict';
+
+var chunkSDXDHVTV_cjs = require('../chunk-SDXDHVTV.cjs');
+
+
+
+Object.defineProperty(exports, "aggregatePolicyOutcomes", {
+  enumerable: true,
+  get: function () { return chunkSDXDHVTV_cjs.aggregatePolicyOutcomes; }
+});
+Object.defineProperty(exports, "assertPolicyId", {
+  enumerable: true,
+  get: function () { return chunkSDXDHVTV_cjs.assertPolicyId; }
+});
+Object.defineProperty(exports, "evaluatePolicyDefinition", {
+  enumerable: true,
+  get: function () { return chunkSDXDHVTV_cjs.evaluatePolicyDefinition; }
+});
+Object.defineProperty(exports, "evaluatePolicyDefinitions", {
+  enumerable: true,
+  get: function () { return chunkSDXDHVTV_cjs.evaluatePolicyDefinitions; }
+});
+Object.defineProperty(exports, "evaluateRegisteredPolicies", {
+  enumerable: true,
+  get: function () { return chunkSDXDHVTV_cjs.evaluateRegisteredPolicies; }
+});
+Object.defineProperty(exports, "getRegisteredPolicyIds", {
+  enumerable: true,
+  get: function () { return chunkSDXDHVTV_cjs.getRegisteredPolicyIds; }
+});
+Object.defineProperty(exports, "registerPolicy", {
+  enumerable: true,
+  get: function () { return chunkSDXDHVTV_cjs.registerPolicy; }
+});
+Object.defineProperty(exports, "registerPolicyIfMissing", {
+  enumerable: true,
+  get: function () { return chunkSDXDHVTV_cjs.registerPolicyIfMissing; }
+});
+Object.defineProperty(exports, "resolvePolicy", {
+  enumerable: true,
+  get: function () { return chunkSDXDHVTV_cjs.resolvePolicy; }
+});
+Object.defineProperty(exports, "validateDataPolicyDefinition", {
+  enumerable: true,
+  get: function () { return chunkSDXDHVTV_cjs.validateDataPolicyDefinition; }
+});
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/policies/index.cjs.map

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

package/dist/policies/index.d.cts

@@ -0,0 +1,143 @@
+type PolicyEvaluationResult = "pass" | "warn" | "block";
+type PolicyKind = "code" | "data" | "hybrid";
+type PolicyId = `${string}.v${number}`;
+type PolicyEvaluationMode = "preview" | "execute";
+declare function assertPolicyId(policyId: string): asserts policyId is PolicyId;
+interface PolicyContext<TDb = unknown> {
+    tenantId: string;
+    spaceId: string;
+    actionInvocationId: string;
+    actionId: string;
+    parameters: unknown;
+    db: TDb;
+    now?: Date;
+    mode?: PolicyEvaluationMode;
+}
+interface PolicyOutcome {
+    policyId: PolicyId;
+    policyVersion: number;
+    policyKind?: PolicyKind;
+    result: PolicyEvaluationResult;
+    reason?: string;
+    metadata?: Record<string, unknown>;
+    dispatchEvidence?: PolicyDispatchEvidence;
+}
+interface PolicyEvaluator<TDb = unknown> {
+    policyId: PolicyId;
+    version: number;
+    kind?: Extract<PolicyKind, "code">;
+    previewSafe?: boolean;
+    evaluate: (ctx: PolicyContext<TDb>) => Promise<PolicyOutcome>;
+}
+type DataPolicySource = "parameters" | "context";
+type DataPolicyLiteral = string | number | boolean | null;
+type DataPolicyComparisonOperator = "exists" | "equals" | "notEquals" | "gt" | "gte" | "lt" | "lte";
+interface DataPolicySourceReference {
+    source: DataPolicySource;
+    path: string;
+}
+type DataPolicyCondition = {
+    conditionId: string;
+    type: "always";
+    result: PolicyEvaluationResult;
+    reason?: string;
+} | {
+    conditionId: string;
+    type: "parameter";
+    path: string;
+    operator: DataPolicyComparisonOperator;
+    value?: DataPolicyLiteral;
+    onPass?: PolicyEvaluationResult;
+    onFail?: PolicyEvaluationResult;
+    reason?: string;
+} | {
+    conditionId: string;
+    type: "comparison";
+    left: DataPolicySourceReference;
+    operator: DataPolicyComparisonOperator;
+    value?: DataPolicyLiteral;
+    onPass?: PolicyEvaluationResult;
+    onFail?: PolicyEvaluationResult;
+    reason?: string;
+} | {
+    conditionId: string;
+    type: "all" | "any";
+    conditions: DataPolicyCondition[];
+    onPass?: PolicyEvaluationResult;
+    onFail?: PolicyEvaluationResult;
+    reason?: string;
+} | {
+    conditionId: string;
+    type: "not";
+    condition: DataPolicyCondition;
+    onPass?: PolicyEvaluationResult;
+    onFail?: PolicyEvaluationResult;
+    reason?: string;
+};
+interface DataPolicyDefinition {
+    conditions: DataPolicyCondition[];
+    defaultResult?: PolicyEvaluationResult;
+    reason?: string;
+}
+interface DataPolicyValidationResult {
+    valid: boolean;
+    errors: string[];
+}
+interface PolicyFallbackDefinition {
+    codeEvaluatorPolicyId: PolicyId;
+    onResults?: PolicyEvaluationResult[];
+    triggers?: PolicyFallbackTrigger[];
+    reason?: string;
+}
+type PolicyFallbackTrigger = "data_result" | "missing_data_definition" | "invalid_data_definition";
+interface DataPolicyConditionResult {
+    conditionId: string;
+    passed: boolean;
+    result: PolicyEvaluationResult;
+    reason?: string;
+}
+interface RuntimePolicyDefinition {
+    policyId: PolicyId;
+    policyVersion: number;
+    kind: PolicyKind;
+    dataDefinition?: DataPolicyDefinition;
+    codeEvaluatorPolicyId?: PolicyId;
+    fallback?: PolicyFallbackDefinition;
+}
+interface PolicyDispatchEvidence {
+    policyKind: PolicyKind;
+    policyId?: PolicyId;
+    policyVersion?: number;
+    dispatchPath: Array<"data" | "code" | "fallback">;
+    data?: {
+        definitionVersion: number;
+        definitionStatus: "evaluated" | "missing" | "invalid";
+        conditionResults: DataPolicyConditionResult[];
+        validationErrors?: string[];
+    };
+    code?: {
+        requestedPolicyId?: PolicyId;
+        policyId: PolicyId;
+        version?: number;
+        registered: boolean;
+    };
+    fallback?: {
+        used: boolean;
+        trigger: PolicyFallbackTrigger | "not_triggered";
+        reason: string;
+        fromResult?: PolicyEvaluationResult;
+        definitionVersion: number;
+        codeEvaluatorPolicyId: PolicyId;
+    };
+}
+declare function registerPolicy(evaluator: PolicyEvaluator): void;
+declare function registerPolicyIfMissing(evaluator: PolicyEvaluator): void;
+declare function resolvePolicy(policyId: PolicyId): PolicyEvaluator | undefined;
+declare function getRegisteredPolicyIds(): PolicyId[];
+declare function evaluateRegisteredPolicies(policyIds: PolicyId[], ctx: PolicyContext): Promise<PolicyOutcome[]>;
+declare function evaluatePolicyDefinitions(policies: RuntimePolicyDefinition[], ctx: PolicyContext): Promise<PolicyOutcome[]>;
+declare function evaluatePolicyDefinition(policy: RuntimePolicyDefinition, ctx: PolicyContext): Promise<PolicyOutcome>;
+declare function validateDataPolicyDefinition(definition: DataPolicyDefinition): DataPolicyValidationResult;
+declare function aggregatePolicyOutcomes(outcomes: PolicyOutcome[]): PolicyOutcome | undefined;
+
+export { type DataPolicyComparisonOperator, type DataPolicyCondition, type DataPolicyConditionResult, type DataPolicyDefinition, type DataPolicyLiteral, type DataPolicySource, type DataPolicySourceReference, type DataPolicyValidationResult, type PolicyContext, type PolicyDispatchEvidence, type PolicyEvaluationMode, type PolicyEvaluationResult, type PolicyEvaluator, type PolicyFallbackDefinition, type PolicyFallbackTrigger, type PolicyId, type PolicyKind, type PolicyOutcome, type RuntimePolicyDefinition, aggregatePolicyOutcomes, assertPolicyId, evaluatePolicyDefinition, evaluatePolicyDefinitions, evaluateRegisteredPolicies, getRegisteredPolicyIds, registerPolicy, registerPolicyIfMissing, resolvePolicy, validateDataPolicyDefinition };