onroute-policy-engine 0.1.0

package/README.md

@@ -0,0 +1,49 @@
+A JSON-based rules engine to validate onRouteBC permit applications against commercial vehicle policy.
+
+## Synopsis
+```orbc-policy-engine``` is a library designed to compare a commercial vehicle permit application against policy expressed in JSON format, and return a list of policy violations as well as other informational policy messages related to the permit.
+
+```orbc-policy-engine``` makes use of https://github.com/CacheControl/json-rules-engine for rules engine functionality. Complex rules are modeled by extending the core ```json-rules-engine``` operators and other capabilities.
+
+## Usage
+```js
+import Policy from 'orbc-policy-engine';
+
+// Instantiate a new Policy object
+// policyConfiguration is a JSON object of type PolicyDefinition
+const policy: Policy = new Policy(policyDefinition);
+
+// Get list of all available permit types (ID and name)
+const permitTypes: Map<string, string> = policy.getPermitTypes();
+
+// Get list of all available commodities (ID and name)
+const commodities: Map<string, string> = policy.getCommodities();
+
+// Get list of all available power unit types
+const powerUnits: Map<string, string> = policy.getPowerUnitTypes();
+
+// Get list of all available trailer types
+const trailers: Map<string, string> = policy.getTrailerTypes();
+
+// Get list of all valid commodities for a given permit type
+const commodities: Map<string, string> = policy.getCommodities(permitTypeId);
+
+// Get list of all vehicle types valid to be added to a configuration,
+// by permit type and commodity. Requires supplying the vehicles already
+// added to the configuration, or empty array if starting from scratch
+const allowableVehicles: Map<string, string> = policy.getAllowableVehicles(
+  permitTypeId, 
+  commodityId, 
+  currentConfiguration);
+
+// Validate a permit application against policy
+// permitApplication is a JSON object of type PermitApplication
+// A PermitApplication is just the standard permitData object wrapped
+// in an object with a permitType key. For example:
+// {
+//   permitType: 'TROS',
+//   permitData: { ... }
+// }
+const results: ValidationResults = policy.validate(permitApplication);
+```
+

package/dist/enum/facts.d.ts

@@ -0,0 +1,5 @@
+export declare enum PolicyFacts {
+    AllowedVehicles = "allowedVehicles",
+    DaysInPermitYear = "daysInPermitYear",
+    ValidationDate = "validationDate"
+}

package/dist/enum/facts.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolicyFacts = void 0;
+var PolicyFacts;
+(function (PolicyFacts) {
+    PolicyFacts["AllowedVehicles"] = "allowedVehicles";
+    PolicyFacts["DaysInPermitYear"] = "daysInPermitYear";
+    PolicyFacts["ValidationDate"] = "validationDate";
+})(PolicyFacts || (exports.PolicyFacts = PolicyFacts = {}));

package/dist/enum/index.d.ts

@@ -0,0 +1,5 @@
+export { PolicyFacts } from './facts';
+export { PermitAppInfo } from './permit-app-info';
+export { RelativePosition } from './relative-position';
+export { ValidationResultCode } from './validation-result-code';
+export { ValidationResultType } from './validation-result-type';

package/dist/enum/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationResultType = exports.ValidationResultCode = exports.RelativePosition = exports.PermitAppInfo = exports.PolicyFacts = void 0;
+var facts_1 = require("./facts");
+Object.defineProperty(exports, "PolicyFacts", { enumerable: true, get: function () { return facts_1.PolicyFacts; } });
+var permit_app_info_1 = require("./permit-app-info");
+Object.defineProperty(exports, "PermitAppInfo", { enumerable: true, get: function () { return permit_app_info_1.PermitAppInfo; } });
+var relative_position_1 = require("./relative-position");
+Object.defineProperty(exports, "RelativePosition", { enumerable: true, get: function () { return relative_position_1.RelativePosition; } });
+var validation_result_code_1 = require("./validation-result-code");
+Object.defineProperty(exports, "ValidationResultCode", { enumerable: true, get: function () { return validation_result_code_1.ValidationResultCode; } });
+var validation_result_type_1 = require("./validation-result-type");
+Object.defineProperty(exports, "ValidationResultType", { enumerable: true, get: function () { return validation_result_type_1.ValidationResultType; } });

package/dist/enum/permit-app-info.d.ts

@@ -0,0 +1,10 @@
+/**
+ * This enum represents a subset of commonly-used paths and
+ * other information in permit applications which may be
+ * referenced from within source code.
+ */
+export declare enum PermitAppInfo {
+    PermitStartDate = "permitData.startDate",
+    PermitDateFormat = "YYYY-MM-DD",
+    CompanyName = "permitData.companyName"
+}

package/dist/enum/permit-app-info.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PermitAppInfo = void 0;
+/**
+ * This enum represents a subset of commonly-used paths and
+ * other information in permit applications which may be
+ * referenced from within source code.
+ */
+var PermitAppInfo;
+(function (PermitAppInfo) {
+    PermitAppInfo["PermitStartDate"] = "permitData.startDate";
+    PermitAppInfo["PermitDateFormat"] = "YYYY-MM-DD";
+    PermitAppInfo["CompanyName"] = "permitData.companyName";
+})(PermitAppInfo || (exports.PermitAppInfo = PermitAppInfo = {}));

package/dist/enum/relative-position.d.ts

@@ -0,0 +1,6 @@
+export declare enum RelativePosition {
+    Before = "before",
+    After = "after",
+    First = "first",
+    Last = "last"
+}

package/dist/enum/relative-position.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelativePosition = void 0;
+var RelativePosition;
+(function (RelativePosition) {
+    RelativePosition["Before"] = "before";
+    RelativePosition["After"] = "after";
+    RelativePosition["First"] = "first";
+    RelativePosition["Last"] = "last";
+})(RelativePosition || (exports.RelativePosition = RelativePosition = {}));

package/dist/enum/validation-result-code.d.ts

@@ -0,0 +1,6 @@
+export declare enum ValidationResultCode {
+    PermitTypeUnknown = "permit-type-unknown",
+    FieldValidationError = "field-validation-error",
+    ConfigurationInvalid = "configuration-invalid",
+    GeneralResult = "general-result"
+}

package/dist/enum/validation-result-code.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationResultCode = void 0;
+var ValidationResultCode;
+(function (ValidationResultCode) {
+    ValidationResultCode["PermitTypeUnknown"] = "permit-type-unknown";
+    ValidationResultCode["FieldValidationError"] = "field-validation-error";
+    ValidationResultCode["ConfigurationInvalid"] = "configuration-invalid";
+    ValidationResultCode["GeneralResult"] = "general-result";
+})(ValidationResultCode || (exports.ValidationResultCode = ValidationResultCode = {}));

package/dist/enum/validation-result-type.d.ts

@@ -0,0 +1,6 @@
+export declare enum ValidationResultType {
+    Violation = "violation",
+    Requirement = "requirement",
+    Warning = "warning",
+    Information = "information"
+}

package/dist/enum/validation-result-type.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationResultType = void 0;
+var ValidationResultType;
+(function (ValidationResultType) {
+    ValidationResultType["Violation"] = "violation";
+    ValidationResultType["Requirement"] = "requirement";
+    ValidationResultType["Warning"] = "warning";
+    ValidationResultType["Information"] = "information";
+})(ValidationResultType || (exports.ValidationResultType = ValidationResultType = {}));

package/dist/helper/facts.helper.d.ts

@@ -0,0 +1,15 @@
+import { Engine } from 'json-rules-engine';
+import { PermitFacts } from 'onroute-policy-engine/types';
+/**
+ * Adds runtime facts for the validation. For example, adds the
+ * validation date for comparison against startDate of the permit.
+ * @param engine json-rules-engine Engine instance to add facts to.
+ */
+export declare function addRuntimeFacts(engine: Engine): void;
+/**
+ * Flattens the permit application, using keys taken from the PermitFacts enum so
+ * the facts can be used more easily within validation rules.
+ * @param permitApplication Permit application object to flatten.
+ * @returns Flattened permit application object for validation.
+ */
+export declare function transformPermitFacts(permitApplication: any): PermitFacts;

package/dist/helper/facts.helper.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformPermitFacts = exports.addRuntimeFacts = void 0;
+const dayjs_1 = __importDefault(require("dayjs"));
+const flattie_1 = require("flattie");
+const enum_1 = require("onroute-policy-engine/enum");
+/**
+ * Adds runtime facts for the validation. For example, adds the
+ * validation date for comparison against startDate of the permit.
+ * @param engine json-rules-engine Engine instance to add facts to.
+ */
+function addRuntimeFacts(engine) {
+    const today = (0, dayjs_1.default)().format(enum_1.PermitAppInfo.PermitDateFormat.toString());
+    engine.addFact(enum_1.PolicyFacts.ValidationDate.toString(), today);
+    // Will be either 365 or 366, for use when comparing against
+    // duration for 1 year permits.
+    engine.addFact(enum_1.PolicyFacts.DaysInPermitYear.toString(), async function (params, almanac) {
+        const startDate = await almanac.factValue(enum_1.PermitAppInfo.PermitStartDate.toString());
+        const dateFrom = (0, dayjs_1.default)(startDate, enum_1.PermitAppInfo.PermitDateFormat.toString());
+        return dateFrom.diff(dateFrom.add(1, 'year'), 'day');
+    });
+}
+exports.addRuntimeFacts = addRuntimeFacts;
+/**
+ * Flattens the permit application, using keys taken from the PermitFacts enum so
+ * the facts can be used more easily within validation rules.
+ * @param permitApplication Permit application object to flatten.
+ * @returns Flattened permit application object for validation.
+ */
+function transformPermitFacts(permitApplication) {
+    // Flatten the permit application so all properties can be accessed
+    // by key
+    const permitFacts = (0, flattie_1.flattie)(permitApplication);
+    // Add the app itself as a fact to be used by more complex rules
+    permitFacts.app = permitApplication;
+    return permitFacts;
+}
+exports.transformPermitFacts = transformPermitFacts;

package/dist/helper/lists.helper.d.ts

@@ -0,0 +1,11 @@
+import { IdentifiedObject } from 'onroute-policy-engine/types';
+/**
+ * Extracts a map containing just the ID and name of each of the supplied
+ * identified objects.
+ * @param objects List of identified objects to extract id and name from.
+ * @param filter Optional list of IDs to constrain the map to. Only objects
+ *   with an ID matching one of the elements in the filter will
+ *   be returned. If no filter supplied, all objects will be returned.
+ * @returns Map of object ID to object name.
+ */
+export declare function extractIdentifiedObjects(objects: Array<IdentifiedObject>, filter?: Array<string>): Map<string, string>;

package/dist/helper/lists.helper.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractIdentifiedObjects = void 0;
+/**
+ * Extracts a map containing just the ID and name of each of the supplied
+ * identified objects.
+ * @param objects List of identified objects to extract id and name from.
+ * @param filter Optional list of IDs to constrain the map to. Only objects
+ *   with an ID matching one of the elements in the filter will
+ *   be returned. If no filter supplied, all objects will be returned.
+ * @returns Map of object ID to object name.
+ */
+function extractIdentifiedObjects(objects, filter) {
+    const objectMap = new Map();
+    objects.forEach((o) => {
+        if (!filter || filter.includes(o.id)) {
+            objectMap.set(o.id, o.name);
+        }
+    });
+    return objectMap;
+}
+exports.extractIdentifiedObjects = extractIdentifiedObjects;

package/dist/helper/rules-engine.helper.d.ts

@@ -0,0 +1,10 @@
+import { Engine } from 'json-rules-engine';
+import { Policy } from 'onroute-policy-engine';
+/**
+ * Creates a json-rules-engine Engine object for each permit type specified in
+ * the policy definition, added to a Map. All rules specific to each permit type
+ * will be added to the appropriate Engine instance.
+ * @param policy orbc-policy-engine Policy object containg current policy definition.
+ * @returns Map of json-rules-engines, one per permit type, keyed on permit type ID.
+ */
+export declare function getRulesEngines(policy: Policy): Map<string, Engine>;

package/dist/helper/rules-engine.helper.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRulesEngines = void 0;
+const json_rules_engine_1 = require("json-rules-engine");
+const custom_operators_1 = require("../rule-operator/custom-operators");
+const enum_1 = require("onroute-policy-engine/enum");
+/**
+ * Gets a json-rules-engine with all onRouteBC custom operators added,
+ * and all policy rules that apply to all permit types added.
+ * @param policyDefinition The definition of policy to validate against.
+ * @returns json-rules-engine Engine instance.
+ */
+function getEngine(policyDefinition) {
+    const engine = new json_rules_engine_1.Engine();
+    custom_operators_1.CustomOperators.forEach((o) => engine.addOperator(o));
+    policyDefinition.commonRules.forEach((r) => engine.addRule(r));
+    return engine;
+}
+/**
+ * Creates a json-rules-engine Engine object for each permit type specified in
+ * the policy definition, added to a Map. All rules specific to each permit type
+ * will be added to the appropriate Engine instance.
+ * @param policy orbc-policy-engine Policy object containg current policy definition.
+ * @returns Map of json-rules-engines, one per permit type, keyed on permit type ID.
+ */
+function getRulesEngines(policy) {
+    var _a, _b;
+    const engineMap = new Map();
+    (_b = (_a = policy.policyDefinition) === null || _a === void 0 ? void 0 : _a.permitTypes) === null || _b === void 0 ? void 0 : _b.forEach((permitType) => {
+        var _a;
+        const engine = getEngine(policy.policyDefinition);
+        (_a = permitType.rules) === null || _a === void 0 ? void 0 : _a.forEach((r) => engine.addRule(r));
+        let allowedVehicles;
+        if (permitType.allowedVehicles && permitType.allowedVehicles.length > 0) {
+            allowedVehicles = permitType.allowedVehicles;
+        }
+        else {
+            // If no allowed vehicles are specified, none are permitted
+            allowedVehicles = [];
+        }
+        // Each permit type should have a list of allowed vehicles configured.
+        engine.addFact(enum_1.PolicyFacts.AllowedVehicles.toString(), allowedVehicles);
+        engineMap.set(permitType.id, engine);
+    });
+    return engineMap;
+}
+exports.getRulesEngines = getRulesEngines;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { Policy } from './policy-engine';
+export { ValidationResult } from './validation-result';
+export { ValidationResults } from './validation-results';

package/dist/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationResults = exports.ValidationResult = exports.Policy = void 0;
+var policy_engine_1 = require("./policy-engine");
+Object.defineProperty(exports, "Policy", { enumerable: true, get: function () { return policy_engine_1.Policy; } });
+var validation_result_1 = require("./validation-result");
+Object.defineProperty(exports, "ValidationResult", { enumerable: true, get: function () { return validation_result_1.ValidationResult; } });
+var validation_results_1 = require("./validation-results");
+Object.defineProperty(exports, "ValidationResults", { enumerable: true, get: function () { return validation_results_1.ValidationResults; } });

package/dist/policy-engine.d.ts

@@ -0,0 +1,59 @@
+import { PolicyDefinition, PermitType } from 'onroute-policy-engine/types';
+import { Engine } from 'json-rules-engine';
+import { ValidationResults } from './validation-results';
+/** Class representing commercial vehicle policy. */
+export declare class Policy {
+    /** Object representation of policy definition and rules. */
+    policyDefinition: PolicyDefinition;
+    /**
+     * Map of json-rules-engine instances, one for each
+     * permit type defined in the permit definition. Keyed
+     * on permit type id.
+     */
+    rulesEngines: Map<string, Engine>;
+    /**
+     * Creates a new Policy object.
+     * @param definition Policy definition to validate permits against
+     */
+    constructor(definition: PolicyDefinition);
+    /**
+     * Validates a permit application against the policy definition.
+     * @param permit The permit application to validate against policy
+     * @returns Results of the validation of the permit application
+     */
+    validate(permit: any): Promise<ValidationResults>;
+    /**
+     * Gets a list of all configured permit types in the policy definition.
+     * @returns Map of permit type IDs to permit type names.
+     */
+    getPermitTypes(): Map<string, string>;
+    /**
+     * Gets a list of all configured geographic regions in the policy definition.
+     * @returns Map of geographic region IDs to region names.
+     */
+    getGeographicRegions(): Map<string, string>;
+    /**
+     * Gets a list of all configured commodities in the policy definition.
+     * @param permitTypeId Return only commodities valid for this permit type.
+     *   If not supplied, return all commodities configured in policy. If permit
+     *   type does not require commodity (e.g. 'TROS'), return all commodities.
+     * @returns Map of commodity IDs to commodity names.
+     */
+    getCommodities(permitTypeId?: string): Map<string, string>;
+    /**
+     * Gets a list of all configured power unit types in the policy definition.
+     * @returns Map of power unit type IDs to power unit type names.
+     */
+    getPowerUnitTypes(): Map<string, string>;
+    /**
+     * Gets a list of all configured trailer types in the policy definition.
+     * @returns Map of trailer type IDs to trailer type names.
+     */
+    getTrailerTypes(): Map<string, string>;
+    /**
+     * Gets a full PermitType definition by ID.
+     * @param type Type ID of the permit definition to return.
+     * @returns PermitType definition for the supplied ID.
+     */
+    getPermitTypeDefinition(type?: string): PermitType | null;
+}

package/dist/policy-engine.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Policy = void 0;
+const lists_helper_1 = require("./helper/lists.helper");
+const rules_engine_helper_1 = require("./helper/rules-engine.helper");
+const validation_results_1 = require("./validation-results");
+const validation_result_1 = require("./validation-result");
+const facts_helper_1 = require("./helper/facts.helper");
+const enum_1 = require("onroute-policy-engine/enum");
+/** Class representing commercial vehicle policy. */
+class Policy {
+    /**
+     * Creates a new Policy object.
+     * @param definition Policy definition to validate permits against
+     */
+    constructor(definition) {
+        this.policyDefinition = definition;
+        this.rulesEngines = (0, rules_engine_helper_1.getRulesEngines)(this);
+    }
+    /**
+     * Validates a permit application against the policy definition.
+     * @param permit The permit application to validate against policy
+     * @returns Results of the validation of the permit application
+     */
+    async validate(permit) {
+        const engine = this.rulesEngines.get(permit.permitType);
+        if (!engine) {
+            // If the permit type being validated has no configuration in the
+            // policy definition, there will be no engine for it. Return with
+            // a single violation result.
+            const validationResult = new validation_results_1.ValidationResults();
+            validationResult.violations.push(new validation_result_1.ValidationResult(enum_1.ValidationResultType.Violation, enum_1.ValidationResultCode.PermitTypeUnknown, `Permit type ${permit.permitType} unknown`));
+            return validationResult;
+        }
+        else {
+            // Add facts specific to this run of the validation (e.g. validation
+            // date for comparison against start date of the permit).
+            (0, facts_helper_1.addRuntimeFacts)(engine);
+            const permitFacts = (0, facts_helper_1.transformPermitFacts)(permit);
+            // Run the json-rules-engine against the permit facts
+            const engineResult = await engine.run(permitFacts);
+            // Wrap the json-rules-engine result in a ValidationResult object
+            return new validation_results_1.ValidationResults(engineResult);
+        }
+    }
+    /**
+     * Gets a list of all configured permit types in the policy definition.
+     * @returns Map of permit type IDs to permit type names.
+     */
+    getPermitTypes() {
+        const permitTypes = (0, lists_helper_1.extractIdentifiedObjects)(this.policyDefinition.permitTypes);
+        return permitTypes;
+    }
+    /**
+     * Gets a list of all configured geographic regions in the policy definition.
+     * @returns Map of geographic region IDs to region names.
+     */
+    getGeographicRegions() {
+        const geographicRegions = (0, lists_helper_1.extractIdentifiedObjects)(this.policyDefinition.geographicRegions);
+        return geographicRegions;
+    }
+    /**
+     * Gets a list of all configured commodities in the policy definition.
+     * @param permitTypeId Return only commodities valid for this permit type.
+     *   If not supplied, return all commodities configured in policy. If permit
+     *   type does not require commodity (e.g. 'TROS'), return all commodities.
+     * @returns Map of commodity IDs to commodity names.
+     */
+    getCommodities(permitTypeId) {
+        const permitType = this.getPermitTypeDefinition(permitTypeId);
+        const commodities = (0, lists_helper_1.extractIdentifiedObjects)(this.policyDefinition.commodities, permitType === null || permitType === void 0 ? void 0 : permitType.allowedCommodities);
+        return commodities;
+    }
+    /**
+     * Gets a list of all configured power unit types in the policy definition.
+     * @returns Map of power unit type IDs to power unit type names.
+     */
+    getPowerUnitTypes() {
+        const powerUnitTypes = (0, lists_helper_1.extractIdentifiedObjects)(this.policyDefinition.vehicleTypes.powerUnitTypes);
+        return powerUnitTypes;
+    }
+    /**
+     * Gets a list of all configured trailer types in the policy definition.
+     * @returns Map of trailer type IDs to trailer type names.
+     */
+    getTrailerTypes() {
+        const trailerTypes = (0, lists_helper_1.extractIdentifiedObjects)(this.policyDefinition.vehicleTypes.trailerTypes);
+        return trailerTypes;
+    }
+    /**
+     * Gets a full PermitType definition by ID.
+     * @param type Type ID of the permit definition to return.
+     * @returns PermitType definition for the supplied ID.
+     */
+    getPermitTypeDefinition(type) {
+        let permitType;
+        if (this.policyDefinition.permitTypes) {
+            permitType = this.policyDefinition.permitTypes.find((p) => p.id === type);
+        }
+        if (permitType) {
+            return permitType;
+        }
+        else {
+            return null;
+        }
+    }
+}
+exports.Policy = Policy;

package/dist/rule-operator/custom-operators.d.ts

@@ -0,0 +1,3 @@
+import { Operator } from 'json-rules-engine';
+declare const CustomOperators: Array<Operator>;
+export { CustomOperators };

package/dist/rule-operator/custom-operators.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomOperators = void 0;
+const json_rules_engine_1 = require("json-rules-engine");
+const enum_1 = require("onroute-policy-engine/enum");
+const dayjs_1 = __importDefault(require("dayjs"));
+function stringValidator(a) {
+    return typeof a === 'string';
+}
+function dateStringValidator(a) {
+    const d = (0, dayjs_1.default)(a, enum_1.PermitAppInfo.PermitDateFormat.toString());
+    return d.isValid();
+}
+const CustomOperators = [];
+exports.CustomOperators = CustomOperators;
+CustomOperators.push(new json_rules_engine_1.Operator('stringMinimumLength', (a, b) => a.trim().length >= b, stringValidator));
+CustomOperators.push(new json_rules_engine_1.Operator('dateLessThan', (a, b) => {
+    const firstDate = (0, dayjs_1.default)(a, enum_1.PermitAppInfo.PermitDateFormat.toString());
+    const secondDate = (0, dayjs_1.default)(b, enum_1.PermitAppInfo.PermitDateFormat.toString());
+    return firstDate.diff(secondDate) < 0;
+}, dateStringValidator));
+CustomOperators.push(new json_rules_engine_1.Operator('regex', (a, b) => RegExp(b).exec(a) !== null, stringValidator));

package/dist/types/commodity.d.ts

@@ -0,0 +1,5 @@
+import { IdentifiedObject, PowerUnit, Trailer } from 'onroute-policy-engine/types';
+export type Commodity = IdentifiedObject & {
+    powerUnits?: Array<PowerUnit>;
+    trailers?: Array<Trailer>;
+};

package/dist/types/commodity.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/dimension-modifier.d.ts

@@ -0,0 +1,9 @@
+import { SelfIssuable } from 'onroute-policy-engine/types';
+export type DimensionModifier = SelfIssuable & {
+    position: string;
+    type?: string;
+    category?: string;
+    axles?: number;
+    minInterAxleSpacing?: number;
+    maxInterAxleSpacing?: number;
+};

package/dist/types/dimension-modifier.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/facts.d.ts

@@ -0,0 +1,10 @@
+export type PermitFacts = {
+    companyName?: string;
+    duration?: number;
+    permitType?: string;
+    startDate?: string;
+    vehicleIdentificationNumber?: string;
+    vehiclePlate?: string;
+    vehicleType?: string;
+    app?: object;
+};

package/dist/types/facts.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/geographic-region.d.ts

@@ -0,0 +1,4 @@
+import { IdentifiedObject } from 'onroute-policy-engine/types';
+export type GeographicRegion = IdentifiedObject & {
+    description?: string;
+};

package/dist/types/geographic-region.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/identified-object.d.ts

@@ -0,0 +1,4 @@
+export type IdentifiedObject = {
+    id: string;
+    name: string;
+};

package/dist/types/identified-object.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/index.d.ts

@@ -0,0 +1,14 @@
+export { Commodity } from './commodity';
+export { DimensionModifier } from './dimension-modifier';
+export { PermitFacts } from './facts';
+export { GeographicRegion } from './geographic-region';
+export { IdentifiedObject } from './identified-object';
+export { PermitType } from './permit-type';
+export { PolicyDefinition } from './policy-definition';
+export { RegionSizeOverride } from './region-size-override';
+export { SelfIssuable } from './self-issuable';
+export { SizeDimension } from './size-dimension';
+export { VehicleCategory, PowerUnitCategory, TrailerCategory, VehicleCategories, } from './vehicle-category';
+export { VehicleType, PowerUnitType, TrailerType, VehicleTypes, } from './vehicle-type';
+export { Vehicle, PowerUnit, Trailer } from './vehicle';
+export { WeightDimension, PowerUnitWeightDimension, TrailerWeightDimension, DefaultWeightDimensions, } from './weight-dimension';

package/dist/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/permit-type.d.ts

@@ -0,0 +1,11 @@
+import { RuleProperties } from 'json-rules-engine';
+import { IdentifiedObject } from 'onroute-policy-engine/types';
+export type PermitType = IdentifiedObject & {
+    routingRequired: boolean;
+    weightDimensionRequired: boolean;
+    sizeDimensionRequired: boolean;
+    commodityRequired: boolean;
+    allowedVehicles: Array<string>;
+    allowedCommodities?: Array<string>;
+    rules?: Array<RuleProperties>;
+};

package/dist/types/permit-type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/policy-definition.d.ts

@@ -0,0 +1,13 @@
+import { GeographicRegion, PermitType, DefaultWeightDimensions, VehicleTypes, Commodity, SizeDimension, VehicleCategories } from 'onroute-policy-engine/types';
+import { RuleProperties } from 'json-rules-engine';
+export type PolicyDefinition = {
+    version: string;
+    geographicRegions: Array<GeographicRegion>;
+    permitTypes: Array<PermitType>;
+    commonRules: Array<RuleProperties>;
+    globalWeightDefaults: DefaultWeightDimensions;
+    globalSizeDefaults: SizeDimension;
+    vehicleCategories: VehicleCategories;
+    vehicleTypes: VehicleTypes;
+    commodities: Array<Commodity>;
+};

package/dist/types/policy-definition.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/region-size-override.d.ts

@@ -0,0 +1,6 @@
+export type RegionSizeOverride = {
+    region: string;
+    width?: number;
+    height?: number;
+    length?: number;
+};

package/dist/types/region-size-override.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/self-issuable.d.ts

@@ -0,0 +1,3 @@
+export type SelfIssuable = {
+    canSelfIssue?: boolean;
+};

package/dist/types/self-issuable.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/size-dimension.d.ts

@@ -0,0 +1,10 @@
+import { DimensionModifier, RegionSizeOverride } from 'onroute-policy-engine/types';
+export type SizeDimension = {
+    frontProjection: number;
+    rearProjection: number;
+    width: number;
+    height: number;
+    length: number;
+    modifiers?: Array<DimensionModifier>;
+    regions?: Array<RegionSizeOverride>;
+};

package/dist/types/size-dimension.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/vehicle-category.d.ts

@@ -0,0 +1,14 @@
+import { IdentifiedObject, SizeDimension, PowerUnitWeightDimension, TrailerWeightDimension } from 'onroute-policy-engine/types';
+export type VehicleCategory = IdentifiedObject & {
+    defaultSizeDimensions?: SizeDimension;
+};
+export type PowerUnitCategory = VehicleCategory & {
+    defaultWeightDimensions?: Array<PowerUnitWeightDimension>;
+};
+export type TrailerCategory = VehicleCategory & {
+    defaultWeightDimensions?: Array<TrailerWeightDimension>;
+};
+export type VehicleCategories = {
+    powerUnitCategories: Array<PowerUnitCategory>;
+    trailerCategories: Array<TrailerCategory>;
+};

package/dist/types/vehicle-category.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/vehicle-type.d.ts

@@ -0,0 +1,15 @@
+import { IdentifiedObject, SizeDimension, PowerUnitWeightDimension, TrailerWeightDimension } from 'onroute-policy-engine/types';
+export type VehicleType = IdentifiedObject & {
+    category: string;
+    defaultSizeDimensions?: SizeDimension;
+};
+export type PowerUnitType = VehicleType & {
+    defaultWeightDimensions?: Array<PowerUnitWeightDimension>;
+};
+export type TrailerType = VehicleType & {
+    defaultWeightDimensions?: Array<TrailerWeightDimension>;
+};
+export type VehicleTypes = {
+    powerUnitTypes: Array<PowerUnitType>;
+    trailerTypes: Array<TrailerType>;
+};

package/dist/types/vehicle-type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/vehicle.d.ts

@@ -0,0 +1,12 @@
+import { SizeDimension, PowerUnitWeightDimension, TrailerWeightDimension } from 'onroute-policy-engine/types';
+export type Vehicle = {
+    type: string;
+    canFollow: Array<string>;
+    sizeDimensions?: Array<SizeDimension>;
+};
+export type PowerUnit = Vehicle & {
+    weightDimensions?: Array<PowerUnitWeightDimension>;
+};
+export type Trailer = Vehicle & {
+    weightDimensions?: Array<TrailerWeightDimension>;
+};

package/dist/types/vehicle.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/weight-dimension.d.ts

@@ -0,0 +1,19 @@
+import { DimensionModifier, SelfIssuable } from 'onroute-policy-engine/types';
+export type WeightDimension = SelfIssuable & {
+    axles: number;
+    modifiers?: Array<DimensionModifier>;
+};
+export type PowerUnitWeightDimension = WeightDimension & {
+    saLegal?: number;
+    saPermittable?: number;
+    daLegal?: number;
+    daPermittable?: number;
+};
+export type TrailerWeightDimension = WeightDimension & {
+    legal?: number;
+    permittable?: number;
+};
+export type DefaultWeightDimensions = {
+    powerUnits: Array<PowerUnitWeightDimension>;
+    trailers: Array<TrailerWeightDimension>;
+};

package/dist/types/weight-dimension.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/validation-result.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Represents a single validation result when a permit application is
+ * validated against policy. A single validation run can result in multiple
+ * validation result messages.
+ */
+export declare class ValidationResult {
+    /**
+     * Creates a new ValidationResult from the supplied type, code, and message.
+     *
+     * @param type type of result, one of the ValidationResultType enum
+     * @param code code for identifying common categories of results
+     * @param message text message describing the result
+     */
+    constructor(type: string, code: string, message: string);
+    type: string;
+    code: string;
+    message: string;
+    fieldReference?: string;
+}

package/dist/validation-result.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationResult = void 0;
+/**
+ * Represents a single validation result when a permit application is
+ * validated against policy. A single validation run can result in multiple
+ * validation result messages.
+ */
+class ValidationResult {
+    /**
+     * Creates a new ValidationResult from the supplied type, code, and message.
+     *
+     * @param type type of result, one of the ValidationResultType enum
+     * @param code code for identifying common categories of results
+     * @param message text message describing the result
+     */
+    constructor(type, code, message) {
+        this.type = type;
+        this.code = code;
+        this.message = message;
+    }
+}
+exports.ValidationResult = ValidationResult;

package/dist/validation-results.d.ts

@@ -0,0 +1,28 @@
+import { EngineResult } from 'json-rules-engine';
+import { ValidationResult } from './validation-result';
+/** Represents the results of a permit application validation against policy */
+export declare class ValidationResults {
+    /** Array of policy violations found during validation. */
+    violations: Array<ValidationResult>;
+    /**
+     * Array of additional requirements found during validation. For example,
+     * a permit may require that other additional permits be applied for in
+     * order to be legal.
+     */
+    requirements: Array<ValidationResult>;
+    /** Array of policy warnings found during validation. */
+    warnings: Array<ValidationResult>;
+    /**
+     * Array of policy messages found during validation. These should be
+     * considered informational only and do not impact the validity of the
+     * permit.
+     */
+    information: Array<ValidationResult>;
+    /**
+     * Creates a new ValidationResults from the json-rules-engine result.
+     * Populates the violations, requirements, warnings, and messages arrays
+     * based on the events in the json-rules-engine result.
+     * @param engineResult json-rules-engine run result.
+     */
+    constructor(engineResult?: EngineResult);
+}

package/dist/validation-results.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationResults = void 0;
+const validation_result_type_1 = require("./enum/validation-result-type");
+const validation_result_code_1 = require("./enum/validation-result-code");
+const validation_result_1 = require("./validation-result");
+/** Represents the results of a permit application validation against policy */
+class ValidationResults {
+    /**
+     * Creates a new ValidationResults from the json-rules-engine result.
+     * Populates the violations, requirements, warnings, and messages arrays
+     * based on the events in the json-rules-engine result.
+     * @param engineResult json-rules-engine run result.
+     */
+    constructor(engineResult) {
+        /** Array of policy violations found during validation. */
+        this.violations = [];
+        /**
+         * Array of additional requirements found during validation. For example,
+         * a permit may require that other additional permits be applied for in
+         * order to be legal.
+         */
+        this.requirements = [];
+        /** Array of policy warnings found during validation. */
+        this.warnings = [];
+        /**
+         * Array of policy messages found during validation. These should be
+         * considered informational only and do not impact the validity of the
+         * permit.
+         */
+        this.information = [];
+        if (engineResult) {
+            engineResult.events.forEach((e) => {
+                var _a, _b, _c, _d, _e, _f;
+                const message = (_b = (_a = e.params) === null || _a === void 0 ? void 0 : _a.message) !== null && _b !== void 0 ? _b : `Unknown message: params=${JSON.stringify(e.params)}`;
+                const code = (_d = (_c = e.params) === null || _c === void 0 ? void 0 : _c.code) !== null && _d !== void 0 ? _d : validation_result_code_1.ValidationResultCode.GeneralResult;
+                const type = (_e = e.type) !== null && _e !== void 0 ? _e : validation_result_type_1.ValidationResultType.Violation.toString();
+                const result = new validation_result_1.ValidationResult(type, code, message);
+                result.fieldReference = (_f = e.params) === null || _f === void 0 ? void 0 : _f.fieldReference;
+                switch (type) {
+                    case validation_result_type_1.ValidationResultType.Violation:
+                        this.violations.push(result);
+                        break;
+                    case validation_result_type_1.ValidationResultType.Requirement:
+                        this.requirements.push(result);
+                        break;
+                    case validation_result_type_1.ValidationResultType.Warning:
+                        this.warnings.push(result);
+                        break;
+                    case validation_result_type_1.ValidationResultType.Information:
+                        this.information.push(result);
+                        break;
+                    default:
+                        // Treat any unknown validation event as a violation since
+                        // it is an unexpected scenario.
+                        console.log('Unknown validation event encountered');
+                        this.violations.push(new validation_result_1.ValidationResult(validation_result_type_1.ValidationResultType.Violation, validation_result_code_1.ValidationResultCode.GeneralResult, 'Unknown validation event encountered'));
+                }
+            });
+        }
+    }
+}
+exports.ValidationResults = ValidationResults;

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "onroute-policy-engine",
+  "version": "0.1.0",
+  "description": "Policy Engine library for commercial vehicle permitting",
+  "main": "dist/index.js",
+  "exports": {
+    ".": "./dist/index.js",
+    "./types": "./dist/types/index.js",
+    "./enum": "./dist/enum/index.js"
+  },
+  "types": "dist/index.d.ts",
+  "private": false,
+  "scripts": {
+    "clean": "rimraf dist && rimraf -g *.tgz",
+    "test": "jest",
+    "lint": "eslint \"{src,apps,libs,test}/**/*.ts\" --fix",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "build": "tsc",
+    "clean-build": "rimraf dist && rimraf -g *.tgz && tsc"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bcgov/onroutebc.git"
+  },
+  "author": "John Fletcher",
+  "license": "Apache-2.0",
+  "homepage": "https://github.com/bcgov/onroutebc#readme",    
+  "devDependencies": {
+    "@types/jest": "^29.5.12",
+    "@typescript-eslint/eslint-plugin": "^7.5.0",
+    "eslint": "^8.57.0",
+    "eslint-config-prettier": "^9.1.0",
+    "jest": "^29.7.0",
+    "prettier": "^3.2.5",
+    "rimraf": "^5.0.7",
+    "ts-jest": "^29.1.2",
+    "typescript": "^5.4.3"
+  },
+  "dependencies": {
+    "dayjs": "^1.11.10",
+    "flattie": "^1.1.1",
+    "json-rules-engine": "^6.5.0"
+  },
+  "jest": {
+    "moduleFileExtensions": [
+      "js",
+      "json",
+      "ts"
+    ],
+    "rootDir": ".",
+    "roots": [
+      "<rootDir>/src"
+    ],
+    "moduleNameMapper": {
+      "^src/(.*)$": "<rootDir>/src/$1",
+      "^test/(.*)$": "<rootDir>/test/$1"
+    },
+    "testRegex": ".*\\.spec\\.ts$",
+    "transform": {
+      "^.+\\.ts$": "ts-jest"
+    },
+    "collectCoverage": true,
+    "collectCoverageFrom": [
+      "**/*.js"
+    ],
+    "coverageDirectory": "./coverage",
+    "coveragePathIgnorePatterns": [
+      "/node_modules/",
+      "/src/_test/",
+      ".enum.ts",
+      ".interface.ts",
+      "index.ts"
+    ],
+    "testEnvironment": "node"
+  }
+}