@nira-opencrvs/toolkit 1.9.11-rc.1f36427

package/dist/scopes/index.js

@@ -0,0 +1,349 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/scopes/index.ts
+var scopes_exports = {};
+__export(scopes_exports, {
+  ActionScopes: () => ActionScopes,
+  RecordScope: () => RecordScope,
+  RecordScopeType: () => RecordScopeType,
+  SCOPES: () => SCOPES,
+  SearchScopes: () => SearchScopes,
+  findScope: () => findScope,
+  getAuthorizedEventsFromScopes: () => getAuthorizedEventsFromScopes,
+  parseConfigurableScope: () => parseConfigurableScope,
+  parseLiteralScope: () => parseLiteralScope,
+  scopes: () => scopes,
+  stringifyScope: () => stringifyScope
+});
+module.exports = __toCommonJS(scopes_exports);
+
+// ../commons/src/scopes.ts
+var import_zod = require("zod");
+var SCOPES = {
+  // TODO v1.8 legacy scopes
+  BYPASSRATELIMIT: "bypassratelimit",
+  REGISTER: "register",
+  DEMO: "demo",
+  CONFIG: "config",
+  // systems / integrations
+  WEBHOOK: "webhook",
+  NATIONALID: "nationalId",
+  NOTIFICATION_API: "notification-api",
+  RECORDSEARCH: "recordsearch",
+  RECORD_IMPORT: "record.import",
+  RECORD_EXPORT: "record.export",
+  RECORD_REINDEX: "record.reindex",
+  // declare
+  RECORD_DECLARE_BIRTH: "record.declare-birth",
+  RECORD_DECLARE_BIRTH_MY_JURISDICTION: "record.declare-birth:my-jurisdiction",
+  RECORD_DECLARE_DEATH: "record.declare-death",
+  RECORD_DECLARE_DEATH_MY_JURISDICTION: "record.declare-death:my-jurisdiction",
+  RECORD_DECLARE_MARRIAGE: "record.declare-marriage",
+  RECORD_DECLARE_MARRIAGE_MY_JURISDICTION: "record.declare-marriage:my-jurisdiction",
+  RECORD_SUBMIT_INCOMPLETE: "record.declaration-submit-incomplete",
+  // @todo: should this record be removed from events v2?
+  RECORD_SUBMIT_FOR_REVIEW: "record.declaration-submit-for-review",
+  RECORD_UNASSIGN_OTHERS: "record.unassign-others",
+  // validate
+  RECORD_SUBMIT_FOR_APPROVAL: "record.declaration-submit-for-approval",
+  RECORD_SUBMIT_FOR_UPDATES: "record.declaration-submit-for-updates",
+  RECORD_DECLARATION_EDIT: "record.declaration-edit",
+  RECORD_REVIEW_DUPLICATES: "record.review-duplicates",
+  RECORD_DECLARATION_ARCHIVE: "record.declaration-archive",
+  RECORD_DECLARATION_REINSTATE: "record.declaration-reinstate",
+  // register
+  RECORD_REGISTER: "record.register",
+  /**
+   * This scope is used to **print and **issue certified copies of a record
+   * after it has been registered. Previously Registrars had this permission.
+   */
+  RECORD_PRINT_ISSUE_CERTIFIED_COPIES: "record.registration-print&issue-certified-copies",
+  // correct
+  RECORD_REGISTRATION_REQUEST_CORRECTION: "record.registration-request-correction",
+  RECORD_REGISTRATION_CORRECT: "record.registration-correct",
+  RECORD_CONFIRM_REGISTRATION: "record.confirm-registration",
+  RECORD_REJECT_REGISTRATION: "record.reject-registration",
+  // search
+  SEARCH_BIRTH_MY_JURISDICTION: "search.birth:my-jurisdiction",
+  SEARCH_BIRTH: "search.birth",
+  SEARCH_DEATH_MY_JURISDICTION: "search.death:my-jurisdiction",
+  SEARCH_DEATH: "search.death",
+  SEARCH_MARRIAGE_MY_JURISDICTION: "search.marriage:my-jurisdiction",
+  SEARCH_MARRIAGE: "search.marriage",
+  // audit v1.8
+  RECORD_READ: "record.read",
+  // profile
+  PROFILE_ELECTRONIC_SIGNATURE: "profile.electronic-signature",
+  // performance
+  PERFORMANCE_READ: "performance.read",
+  PERFORMANCE_READ_DASHBOARDS: "performance.read-dashboards",
+  PERFORMANCE_EXPORT_VITAL_STATISTICS: "performance.vital-statistics-export",
+  // organisation
+  ORGANISATION_READ_LOCATIONS: "organisation.read-locations:all",
+  ORGANISATION_READ_LOCATIONS_MY_OFFICE: "organisation.read-locations:my-office",
+  ORGANISATION_READ_LOCATIONS_MY_JURISDICTION: "organisation.read-locations:my-jurisdiction",
+  // user
+  USER_READ: "user.read:all",
+  USER_READ_MY_OFFICE: "user.read:my-office",
+  USER_READ_MY_JURISDICTION: "user.read:my-jurisdiction",
+  USER_READ_ONLY_MY_AUDIT: "user.read:only-my-audit",
+  //v1.8
+  USER_CREATE: "user.create:all",
+  USER_CREATE_MY_JURISDICTION: "user.create:my-jurisdiction",
+  USER_UPDATE: "user.update:all",
+  USER_UPDATE_MY_JURISDICTION: "user.update:my-jurisdiction",
+  // config
+  CONFIG_UPDATE_ALL: "config.update:all",
+  // data seeding
+  USER_DATA_SEEDING: "user.data-seeding"
+};
+var LegacyScopes = import_zod.z.union([
+  import_zod.z.literal(SCOPES.BYPASSRATELIMIT),
+  import_zod.z.literal(SCOPES.REGISTER),
+  import_zod.z.literal(SCOPES.DEMO),
+  import_zod.z.literal(SCOPES.CONFIG)
+]);
+var IntegrationScopes = import_zod.z.union([
+  import_zod.z.literal(SCOPES.WEBHOOK),
+  import_zod.z.literal(SCOPES.NATIONALID),
+  import_zod.z.literal(SCOPES.NOTIFICATION_API),
+  import_zod.z.literal(SCOPES.RECORDSEARCH)
+]);
+var InternalOperationsScopes = import_zod.z.union([
+  import_zod.z.literal(SCOPES.RECORD_REINDEX),
+  import_zod.z.literal(SCOPES.RECORD_IMPORT)
+]);
+var DeclareScopes = import_zod.z.union([
+  import_zod.z.literal(SCOPES.RECORD_DECLARE_BIRTH),
+  import_zod.z.literal(SCOPES.RECORD_DECLARE_BIRTH_MY_JURISDICTION),
+  import_zod.z.literal(SCOPES.RECORD_DECLARE_DEATH),
+  import_zod.z.literal(SCOPES.RECORD_DECLARE_DEATH_MY_JURISDICTION),
+  import_zod.z.literal(SCOPES.RECORD_DECLARE_MARRIAGE),
+  import_zod.z.literal(SCOPES.RECORD_DECLARE_MARRIAGE_MY_JURISDICTION),
+  import_zod.z.literal(SCOPES.RECORD_SUBMIT_INCOMPLETE),
+  import_zod.z.literal(SCOPES.RECORD_SUBMIT_FOR_REVIEW)
+]);
+var UnassignScope = import_zod.z.literal(SCOPES.RECORD_UNASSIGN_OTHERS);
+var ValidateScopes = import_zod.z.union([
+  import_zod.z.literal(SCOPES.RECORD_SUBMIT_FOR_APPROVAL),
+  import_zod.z.literal(SCOPES.RECORD_SUBMIT_FOR_UPDATES),
+  import_zod.z.literal(SCOPES.RECORD_DECLARATION_EDIT),
+  import_zod.z.literal(SCOPES.RECORD_REVIEW_DUPLICATES),
+  import_zod.z.literal(SCOPES.RECORD_DECLARATION_ARCHIVE),
+  import_zod.z.literal(SCOPES.RECORD_DECLARATION_REINSTATE)
+]);
+var RegisterScope = import_zod.z.literal(SCOPES.RECORD_REGISTER);
+var CorrectionScopes = import_zod.z.union([
+  import_zod.z.literal(SCOPES.RECORD_REGISTRATION_REQUEST_CORRECTION),
+  import_zod.z.literal(SCOPES.RECORD_REGISTRATION_CORRECT),
+  import_zod.z.literal(SCOPES.RECORD_CONFIRM_REGISTRATION),
+  import_zod.z.literal(SCOPES.RECORD_REJECT_REGISTRATION)
+]);
+var SearchScopes = import_zod.z.union([
+  import_zod.z.literal(SCOPES.SEARCH_BIRTH_MY_JURISDICTION),
+  import_zod.z.literal(SCOPES.SEARCH_BIRTH),
+  import_zod.z.literal(SCOPES.SEARCH_DEATH_MY_JURISDICTION),
+  import_zod.z.literal(SCOPES.SEARCH_DEATH),
+  import_zod.z.literal(SCOPES.SEARCH_MARRIAGE_MY_JURISDICTION),
+  import_zod.z.literal(SCOPES.SEARCH_MARRIAGE)
+]);
+var AuditScopes = import_zod.z.literal(SCOPES.RECORD_READ);
+var PerformanceScopes = import_zod.z.union([
+  import_zod.z.literal(SCOPES.PERFORMANCE_READ),
+  import_zod.z.literal(SCOPES.PERFORMANCE_READ_DASHBOARDS),
+  import_zod.z.literal(SCOPES.PERFORMANCE_EXPORT_VITAL_STATISTICS)
+]);
+var OrganisationScopes = import_zod.z.union([
+  import_zod.z.literal(SCOPES.ORGANISATION_READ_LOCATIONS),
+  import_zod.z.literal(SCOPES.ORGANISATION_READ_LOCATIONS_MY_OFFICE),
+  import_zod.z.literal(SCOPES.ORGANISATION_READ_LOCATIONS_MY_JURISDICTION)
+]);
+var UserScopes = import_zod.z.union([
+  import_zod.z.literal(SCOPES.USER_READ),
+  import_zod.z.literal(SCOPES.USER_READ_MY_OFFICE),
+  import_zod.z.literal(SCOPES.USER_READ_MY_JURISDICTION),
+  import_zod.z.literal(SCOPES.USER_READ_ONLY_MY_AUDIT),
+  import_zod.z.literal(SCOPES.USER_CREATE),
+  import_zod.z.literal(SCOPES.USER_CREATE_MY_JURISDICTION),
+  import_zod.z.literal(SCOPES.USER_UPDATE),
+  import_zod.z.literal(SCOPES.USER_UPDATE_MY_JURISDICTION)
+]);
+var ConfigScope = import_zod.z.literal(SCOPES.CONFIG_UPDATE_ALL);
+var DataSeedingScope = import_zod.z.literal(SCOPES.USER_DATA_SEEDING);
+var LiteralScopes = import_zod.z.union([
+  LegacyScopes,
+  IntegrationScopes,
+  UnassignScope,
+  DeclareScopes,
+  ValidateScopes,
+  RegisterScope,
+  import_zod.z.literal(SCOPES.RECORD_PRINT_ISSUE_CERTIFIED_COPIES),
+  CorrectionScopes,
+  SearchScopes,
+  AuditScopes,
+  import_zod.z.literal(SCOPES.PROFILE_ELECTRONIC_SIGNATURE),
+  PerformanceScopes,
+  OrganisationScopes,
+  UserScopes,
+  ConfigScope,
+  DataSeedingScope,
+  InternalOperationsScopes
+]);
+var rawConfigurableScopeRegex = /^([a-zA-Z][a-zA-Z0-9.-]*(?:\.[a-zA-Z0-9.-]+)*)\[((?:\w+=[\w.-]+(?:\|[\w.-]+)*)(?:,[\w]+=[\w.-]+(?:\|[\w.-]+)*)*)\]$/;
+var rawConfigurableScope = import_zod.z.string().regex(rawConfigurableScopeRegex);
+var CreateUserScope = import_zod.z.object({
+  type: import_zod.z.literal("user.create"),
+  options: import_zod.z.object({
+    role: import_zod.z.array(import_zod.z.string())
+  })
+});
+var EditUserScope = import_zod.z.object({
+  type: import_zod.z.literal("user.edit"),
+  options: import_zod.z.object({
+    role: import_zod.z.array(import_zod.z.string())
+  })
+});
+var WorkqueueScope = import_zod.z.object({
+  type: import_zod.z.literal("workqueue"),
+  options: import_zod.z.object({
+    id: import_zod.z.array(import_zod.z.string())
+  })
+});
+var SearchScope = import_zod.z.object({
+  type: import_zod.z.literal("search"),
+  options: import_zod.z.object({
+    event: import_zod.z.array(import_zod.z.string()).length(1),
+    access: import_zod.z.array(import_zod.z.enum(["my-jurisdiction", "all"])).length(1)
+  })
+});
+var PrintCertifiedCopiesScope = import_zod.z.object({
+  type: import_zod.z.literal("record.registered.print-certified-copies"),
+  options: import_zod.z.object({
+    event: import_zod.z.array(import_zod.z.string()).describe("Event type, e.g. birth, death"),
+    templates: import_zod.z.array(import_zod.z.string()).optional().describe(
+      "Template IDs for certified copies. If not provided, all templates will be used."
+    )
+  })
+});
+var RecordScopeType = import_zod.z.enum([
+  "record.create",
+  "record.read",
+  "record.declare",
+  "record.notify",
+  "record.declared.validate",
+  "record.declared.reject",
+  "record.declared.archive",
+  "record.declared.review-duplicates",
+  "record.register",
+  "record.registered.request-correction",
+  "record.registered.correct",
+  "record.unassign-others"
+]);
+var RecordScope = import_zod.z.object({
+  type: RecordScopeType,
+  options: import_zod.z.object({
+    event: import_zod.z.array(import_zod.z.string()).describe("Event type, e.g. birth, death")
+  })
+}).describe(
+  "Scopes used to check user's permission to perform actions on a record."
+);
+var ConfigurableRawScopes = import_zod.z.discriminatedUnion("type", [
+  SearchScope,
+  PrintCertifiedCopiesScope,
+  CreateUserScope,
+  EditUserScope,
+  WorkqueueScope,
+  RecordScope
+]);
+function flattenAndMergeScopes(scopes2) {
+  if (scopes2.length === 0) return null;
+  const type = scopes2[0].type;
+  const mergedOptions = {};
+  for (const scope of scopes2) {
+    const entries = Object.entries(scope.options);
+    if (entries.length < 2) continue;
+    const sourceValues = entries[0][1];
+    const targetValues = entries[1][1];
+    for (let i = 0; i < sourceValues.length; i++) {
+      mergedOptions[sourceValues[i]] = targetValues[i];
+    }
+  }
+  return { type, options: mergedOptions };
+}
+function findScope(scopes2, scopeType) {
+  const parsedScopes = scopes2.map(parseConfigurableScope);
+  const searchScopes = parsedScopes.filter((scope) => scope?.type === "search");
+  const otherScopes = parsedScopes.filter((scope) => scope?.type !== "search");
+  const mergedSearchScope = flattenAndMergeScopes(searchScopes);
+  return [...otherScopes, mergedSearchScope].find(
+    (scope) => scope?.type === scopeType
+  );
+}
+function getScopeOptions(rawOptions) {
+  return rawOptions.split(",").reduce((acc, option) => {
+    const [key, value] = option.split("=");
+    acc[key] = value.split("|");
+    return acc;
+  }, {});
+}
+function parseConfigurableScope(scope) {
+  const maybeConfigurableScope = rawConfigurableScope.safeParse(scope);
+  if (!maybeConfigurableScope.success) {
+    return;
+  }
+  const rawScope = maybeConfigurableScope.data;
+  const [, type, rawOptions] = rawScope.match(rawConfigurableScopeRegex) ?? [];
+  const options = getScopeOptions(rawOptions);
+  const parsedScope = {
+    type,
+    options
+  };
+  const result = ConfigurableRawScopes.safeParse(parsedScope);
+  return result.success ? result.data : void 0;
+}
+function parseLiteralScope(scope) {
+  const maybeLiteralScope = LiteralScopes.safeParse(scope);
+  if (maybeLiteralScope.success) {
+    return {
+      type: maybeLiteralScope.data
+    };
+  }
+  return;
+}
+function stringifyScope(scope) {
+  const options = Object.entries(scope.options).map(([key, value]) => `${key}=${value.join("|")}`).join(",");
+  return `${scope.type}[${options}]`;
+}
+function getAuthorizedEventsFromScopes(scopes2) {
+  return scopes2.flatMap(({ options }) => {
+    if (options && "event" in options) {
+      return options.event;
+    }
+    return void 0;
+  }).filter((event) => event !== void 0).filter((event, index, self) => self.indexOf(event) === index);
+}
+var scopes = Object.values(SCOPES);
+var ActionScopes = import_zod.z.union([
+  DeclareScopes,
+  ValidateScopes,
+  RegisterScope,
+  import_zod.z.literal(SCOPES.RECORD_PRINT_ISSUE_CERTIFIED_COPIES),
+  CorrectionScopes
+]);

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@nira-opencrvs/toolkit",
+  "version": "1.9.11-rc.1f36427",
+  "description": "OpenCRVS toolkit for building country configurations",
+  "license": "MPL-2.0",
+  "exports": {
+    "./lib": "./dist/lib.js",
+    "./api": "./dist/api/index.js",
+    "./events": "./dist/events/index.js",
+    "./scopes": "./dist/scopes/index.js",
+    "./events/deduplication": "./dist/events/deduplication.js",
+    "./conditionals": "./dist/conditionals/index.js",
+    "./notification": "./dist/notification/index.js"
+  },
+  "scripts": {
+    "build": "./build.sh",
+    "build:all": "lerna run build --include-dependencies --scope @nira-opencrvs/toolkit && ./build.sh"
+  },
+  "dependencies": {
+    "uuid": "^9.0.0",
+    "ajv": "^8.17.1",
+    "ajv-formats": "^3.0.1",
+    "object-hash": "^3.0.0",
+    "superjson": "1.9.0-0",
+    "@trpc/client": "11.4.3",
+    "@trpc/server": "11.4.3",
+    "zod-openapi": "^4.2.4"
+  },
+  "devDependencies": {
+    "@types/uuid": "^9.0.3",
+    "esbuild": "^0.24.0",
+    "typescript": "^5.6.3",
+    "@opencrvs/events": "^1.9.0",
+    "@types/object-hash": "^3.0.6"
+  },
+  "moduleNameMapper": {
+    "@opencrvs/commons/events": "@opencrvs/commons/build/dist/common/events/index.js",
+    "@opencrvs/commons/scopes": "@opencrvs/commons/build/dist/common/scopes.js"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    "lib": ["esnext"],
+    "target": "es2016",
+    "module": "node16",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "declarationMap": true,
+    "rootDir": "./src",
+    "outDir": "dist",
+    "paths": {
+      "@opencrvs/commons/conditionals": [
+        "../commons/src/conditionals/conditionals.ts"
+      ],
+      "@opencrvs/commons/scopes": ["../commons/src/scopes.ts"],
+      "@opencrvs/commons/events": ["../commons/src/events/index.ts"],
+      "@opencrvs/commons/events/deduplication": ["../commons/src/events/deduplication.ts"],
+      "@opencrvs/commons/notification": ["../commons/src/notification/index.ts"]
+    }
+  },
+  "references": [{ "path": "../commons/tsconfig-commonjs.json" }],
+  "include": ["src/**/*.ts"],
+  "exclude": ["**/node_modules/**", "dist"]
+}

package/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["./src/api/index.ts","./src/conditionals/index.ts","./src/events/deduplication.ts","./src/events/index.ts","./src/notification/index.ts","./src/scopes/index.ts"],"version":"5.6.3"}