@aletheia-dev/core 0.1.0 → 0.2.0

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @aletheia-dev/core
 
+## 0.2.0
+
+### Minor Changes
+
+- [#10](https://github.com/akhiljames/aletheia/pull/10) [`1b1c13f`](https://github.com/akhiljames/aletheia/commit/1b1c13f230b10d8d4704196b510edc164d14e7e9) Thanks [@akhiljames](https://github.com/akhiljames)! - New `PolicyPack` schema and helpers (`policy-pack.ts`): a portable set of rules, rule sets,
+  workflows, collection flows and lists (with rows, capped at `POLICY_PACK_MAX_LIST_ROWS`) built
+  from the same input schemas the `PUT` routes accept, plus `PolicyPackKeyRef`
+  (`<kind>:<key>`), `parsePolicyPackKeyRef`, `policyPackKeyRefs` and `policyPackCounts`. It is the
+  body of `POST /definitions/import` and the response of `GET /definitions/export`.
+
 ## 0.1.0
 
 ### Minor Changes

package/dist/index.cjs

@@ -120,12 +120,28 @@ __export(src_exports, {
   NotFoundError: () => NotFoundError,
   NotImplementedError: () => NotImplementedError,
   OutcomeChange: () => OutcomeChange,
+  POLICY_PACK_GROUPS: () => POLICY_PACK_GROUPS,
+  POLICY_PACK_GROUP_KINDS: () => POLICY_PACK_GROUP_KINDS,
+  POLICY_PACK_MAX_LIST_ROWS: () => POLICY_PACK_MAX_LIST_ROWS,
   PluginCallback: () => PluginCallback,
   PluginCallbackSignal: () => PluginCallbackSignal,
   PluginCallbackStatus: () => PluginCallbackStatus,
   PluginDefinition: () => PluginDefinition,
   PluginInvocation: () => PluginInvocation,
   PluginInvocationStatus: () => PluginInvocationStatus,
+  PolicyPack: () => PolicyPack,
+  PolicyPackCollectionFlow: () => PolicyPackCollectionFlow,
+  PolicyPackDefinitions: () => PolicyPackDefinitions,
+  PolicyPackImportResult: () => PolicyPackImportResult,
+  PolicyPackImportedDefinition: () => PolicyPackImportedDefinition,
+  PolicyPackImportedList: () => PolicyPackImportedList,
+  PolicyPackItemKind: () => PolicyPackItemKind,
+  PolicyPackKeyRef: () => PolicyPackKeyRef,
+  PolicyPackList: () => PolicyPackList,
+  PolicyPackName: () => PolicyPackName,
+  PolicyPackRule: () => PolicyPackRule,
+  PolicyPackRuleSet: () => PolicyPackRuleSet,
+  PolicyPackWorkflow: () => PolicyPackWorkflow,
   RemoveListEntriesInput: () => RemoveListEntriesInput,
   RuleDefinition: () => RuleDefinition,
   RuleEvaluation: () => RuleEvaluation,
@@ -184,6 +200,9 @@ __export(src_exports, {
   getPath: () => getPath,
   noopLogger: () => noopLogger,
   normalizeListValue: () => normalizeListValue,
+  parsePolicyPackKeyRef: () => parsePolicyPackKeyRef,
+  policyPackCounts: () => policyPackCounts,
+  policyPackKeyRefs: () => policyPackKeyRefs,
   stepTargets: () => stepTargets,
   systemContext: () => systemContext,
   temporalWorkflowId: () => temporalWorkflowId
@@ -1410,6 +1429,109 @@ var AuditFilter = import_zod21.z.object({
   to: import_zod21.z.coerce.date().optional()
 });
 
+// src/policy-pack.ts
+var import_zod22 = require("zod");
+var POLICY_PACK_MAX_LIST_ROWS = 1e4;
+var PolicyPackRule = UpsertRuleDefinitionInput.extend({ key: DefinitionKey });
+var PolicyPackRuleSet = UpsertRuleSetInput.extend({ key: DefinitionKey });
+var PolicyPackWorkflow = UpsertWorkflowDefinitionInput.extend({ key: DefinitionKey });
+var PolicyPackCollectionFlow = UpsertCollectionFlowInput.extend({ key: DefinitionKey });
+var PolicyPackList = UpsertListInput.extend({
+  key: DefinitionKey,
+  rows: import_zod22.z.array(NewListEntry).max(POLICY_PACK_MAX_LIST_ROWS).default([])
+});
+var POLICY_PACK_GROUPS = [
+  "lists",
+  "rules",
+  "ruleSets",
+  "collectionFlows",
+  "workflows"
+];
+var PolicyPackItemKind = import_zod22.z.enum([...DefinitionKind.options, "list"]);
+var POLICY_PACK_GROUP_KINDS = {
+  lists: "list",
+  rules: "rule",
+  ruleSets: "rule_set",
+  collectionFlows: "collection_flow",
+  workflows: "workflow"
+};
+var PolicyPackDefinitions = import_zod22.z.object({
+  rules: import_zod22.z.array(PolicyPackRule).default([]),
+  ruleSets: import_zod22.z.array(PolicyPackRuleSet).default([]),
+  workflows: import_zod22.z.array(PolicyPackWorkflow).default([]),
+  collectionFlows: import_zod22.z.array(PolicyPackCollectionFlow).default([]),
+  lists: import_zod22.z.array(PolicyPackList).default([])
+}).superRefine((definitions, ctx) => {
+  for (const group of POLICY_PACK_GROUPS) {
+    const seen = /* @__PURE__ */ new Set();
+    definitions[group].forEach((item, index) => {
+      if (seen.has(item.key)) {
+        ctx.addIssue({
+          code: "custom",
+          path: [group, index, "key"],
+          message: `duplicate ${POLICY_PACK_GROUP_KINDS[group].replace(/_/g, " ")} "${item.key}"`
+        });
+      }
+      seen.add(item.key);
+    });
+  }
+});
+var PolicyPackName = import_zod22.z.string().min(1).max(100).regex(/^[a-z0-9][a-z0-9_-]*$/, 'pack names are lowercase letters, digits, "_" or "-"');
+var PolicyPack = import_zod22.z.object({
+  name: PolicyPackName,
+  version: import_zod22.z.string().min(1).max(50),
+  description: import_zod22.z.string().max(2e3).optional(),
+  definitions: PolicyPackDefinitions
+});
+function policyPackCounts(pack) {
+  return {
+    lists: pack.definitions.lists.length,
+    rules: pack.definitions.rules.length,
+    ruleSets: pack.definitions.ruleSets.length,
+    collectionFlows: pack.definitions.collectionFlows.length,
+    workflows: pack.definitions.workflows.length
+  };
+}
+var PolicyPackKeyRef = import_zod22.z.object({ kind: PolicyPackItemKind, key: DefinitionKey });
+function parsePolicyPackKeyRef(value) {
+  const separator = value.indexOf(":");
+  const kind = separator === -1 ? "" : value.slice(0, separator);
+  const key = separator === -1 ? value : value.slice(separator + 1);
+  return PolicyPackKeyRef.parse({ kind, key });
+}
+function policyPackKeyRefs(pack) {
+  return POLICY_PACK_GROUPS.flatMap(
+    (group) => pack.definitions[group].map((item) => `${POLICY_PACK_GROUP_KINDS[group]}:${item.key}`)
+  );
+}
+var PolicyPackImportedDefinition = import_zod22.z.object({
+  kind: DefinitionKind,
+  key: DefinitionKey,
+  id: Id,
+  version: import_zod22.z.number().int().positive(),
+  status: DefinitionStatus,
+  /** Set when the tenant requires approvals and `publish=true` opened a request instead. */
+  approvalId: Id.nullable()
+});
+var PolicyPackImportedList = import_zod22.z.object({
+  key: DefinitionKey,
+  id: Id,
+  created: import_zod22.z.boolean(),
+  added: import_zod22.z.number().int().nonnegative(),
+  skipped: import_zod22.z.number().int().nonnegative(),
+  invalid: import_zod22.z.number().int().nonnegative()
+});
+var PolicyPackImportResult = import_zod22.z.object({
+  name: PolicyPackName,
+  version: import_zod22.z.string(),
+  /** Whether `publish=true` was requested. */
+  publish: import_zod22.z.boolean(),
+  /** With `publish=true` and approvals required: versions are `pending_approval`, not published. */
+  approvalRequired: import_zod22.z.boolean(),
+  definitions: import_zod22.z.array(PolicyPackImportedDefinition),
+  lists: import_zod22.z.array(PolicyPackImportedList)
+});
+
 // src/errors.ts
 var AletheiaError = class extends Error {
   constructor(message, code, status = 500, details) {
@@ -1564,12 +1686,28 @@ var noopLogger = {
   NotFoundError,
   NotImplementedError,
   OutcomeChange,
+  POLICY_PACK_GROUPS,
+  POLICY_PACK_GROUP_KINDS,
+  POLICY_PACK_MAX_LIST_ROWS,
   PluginCallback,
   PluginCallbackSignal,
   PluginCallbackStatus,
   PluginDefinition,
   PluginInvocation,
   PluginInvocationStatus,
+  PolicyPack,
+  PolicyPackCollectionFlow,
+  PolicyPackDefinitions,
+  PolicyPackImportResult,
+  PolicyPackImportedDefinition,
+  PolicyPackImportedList,
+  PolicyPackItemKind,
+  PolicyPackKeyRef,
+  PolicyPackList,
+  PolicyPackName,
+  PolicyPackRule,
+  PolicyPackRuleSet,
+  PolicyPackWorkflow,
   RemoveListEntriesInput,
   RuleDefinition,
   RuleEvaluation,
@@ -1628,6 +1766,9 @@ var noopLogger = {
   getPath,
   noopLogger,
   normalizeListValue,
+  parsePolicyPackKeyRef,
+  policyPackCounts,
+  policyPackKeyRefs,
   stepTargets,
   systemContext,
   temporalWorkflowId