@bernierllc/nevar-operator-registry 0.0.1 → 0.1.0

package/LICENSE

@@ -0,0 +1,5 @@
+Copyright (c) 2025 Bernier LLC
+
+This software is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.

package/README.md

@@ -1,45 +1,86 @@
 # @bernierllc/nevar-operator-registry
 
-## ⚠️ IMPORTANT NOTICE ⚠️
+Operator registry with 12 built-in operators for the Nevar rules engine.
 
-**This package is created solely for the purpose of setting up OIDC (OpenID Connect) trusted publishing with npm.**
+## Installation
 
-This is **NOT** a functional package and contains **NO** code or functionality beyond the OIDC setup configuration.
+```bash
+npm install @bernierllc/nevar-operator-registry
+```
 
-## Purpose
+## Usage
 
-This package exists to:
-1. Configure OIDC trusted publishing for the package name `@bernierllc/nevar-operator-registry`
-2. Enable secure, token-less publishing from CI/CD workflows
-3. Establish provenance for packages published under this name
+```typescript
+import { OperatorRegistry } from '@bernierllc/nevar-operator-registry';
 
-## What is OIDC Trusted Publishing?
+const registry = new OperatorRegistry();
 
-OIDC trusted publishing allows package maintainers to publish packages directly from their CI/CD workflows without needing to manage npm access tokens. Instead, it uses OpenID Connect to establish trust between the CI/CD provider (like GitHub Actions) and npm.
+// All 12 built-in operators are pre-registered
+registry.evaluate('eq', 'hello', 'hello'); // true
+registry.evaluate('gt', 10, 5);            // true
+registry.evaluate('in', 'a', ['a', 'b']);  // true
+registry.evaluate('is_true', true, null);  // true
 
-## Setup Instructions
+// List all operators
+const operators = registry.list();
 
-To properly configure OIDC trusted publishing for this package:
+// Filter by category
+const comparisons = registry.getByCategory('comparison');
 
-1. Go to [npmjs.com](https://www.npmjs.com/) and navigate to your package settings
-2. Configure the trusted publisher (e.g., GitHub Actions)
-3. Specify the repository and workflow that should be allowed to publish
-4. Use the configured workflow to publish your actual package
+// Register custom operators
+registry.register('starts_with', {
+  label: 'Starts With',
+  category: 'string',
+  evaluate: (field, target) => String(field).startsWith(String(target)),
+  schema: z.string(),
+  fieldTypes: ['string'],
+});
+```
 
-## DO NOT USE THIS PACKAGE
+## Built-in Operators
 
-This package is a placeholder for OIDC configuration only. It:
-- Contains no executable code
-- Provides no functionality
-- Should not be installed as a dependency
-- Exists only for administrative purposes
+| Operator | Category | Description |
+|----------|----------|-------------|
+| eq | comparison | Equal to |
+| neq | comparison | Not equal to |
+| gt | comparison | Greater than |
+| gte | comparison | Greater than or equal |
+| lt | comparison | Less than |
+| lte | comparison | Less than or equal |
+| in | membership | Value is in array |
+| not_in | membership | Value is not in array |
+| contains | membership | Array/string contains value |
+| not_contains | membership | Array/string does not contain value |
+| is_true | boolean | Value is truthy |
+| is_false | boolean | Value is falsy |
 
-## More Information
+## API
 
-For more details about npm's trusted publishing feature, see:
-- [npm Trusted Publishing Documentation](https://docs.npmjs.com/generating-provenance-statements)
-- [GitHub Actions OIDC Documentation](https://docs.github.com/en/actions/deployment/security-hardening-your-deployments/about-security-hardening-with-openid-connect)
+### `OperatorRegistry`
 
----
+Registry for managing built-in and custom operators. All 12 built-in operators are pre-registered on construction.
 
-**Maintained for OIDC setup purposes only**
+**Constructor:** `new OperatorRegistry()`
+
+- `register(name, definition)` - Registers a custom operator. Throws `NevarValidationError` if the name is already registered
+- `get(name)` - Returns the `OperatorDefinition` for the given name, or `undefined`
+- `has(name)` - Returns `true` if the operator is registered
+- `list()` - Returns all operators as serializable `OperatorInfo[]` (without evaluate functions)
+- `getByCategory(category)` - Returns operators filtered by category
+- `evaluate(name, fieldValue, targetValue)` - Evaluates a field value against a target using the named operator. Throws `NevarEvaluationError` for unknown operators
+
+### `builtInOperators`
+
+Exported map of the 12 built-in operator definitions, useful for inspection or testing.
+
+## Integration Documentation
+
+### Logger Integration
+This package does not integrate with `@bernierllc/logger`. As a core package, logger integration is optional and not included by default. Consumers should handle logging at the service layer.
+
+### NeverHub Integration
+This package does not integrate with `@bernierllc/neverhub-adapter`. As a core package, NeverHub integration is not applicable. NeverHub registration should be handled by service-layer packages that compose this package.
+
+## License
+
+Copyright (c) 2025 Bernier LLC. All rights reserved.

package/dist/built-in-operators.d.ts

@@ -0,0 +1,6 @@
+import type { OperatorDefinition } from '@bernierllc/nevar-types';
+/**
+ * All 12 built-in operators for the Nevar rules engine.
+ * Grouped by category: comparison, membership, boolean.
+ */
+export declare const builtInOperators: Record<string, OperatorDefinition>;

package/dist/built-in-operators.js

@@ -0,0 +1,158 @@
+"use strict";
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.builtInOperators = void 0;
+const zod_1 = require("zod");
+/**
+ * All 12 built-in operators for the Nevar rules engine.
+ * Grouped by category: comparison, membership, boolean.
+ */
+exports.builtInOperators = {
+    // --- Comparison operators ---
+    eq: {
+        label: 'Equal',
+        category: 'comparison',
+        evaluate: (fieldValue, targetValue) => {
+            return fieldValue === targetValue;
+        },
+        schema: zod_1.z.unknown(),
+        fieldTypes: ['string', 'number', 'boolean'],
+    },
+    neq: {
+        label: 'Not Equal',
+        category: 'comparison',
+        evaluate: (fieldValue, targetValue) => {
+            return fieldValue !== targetValue;
+        },
+        schema: zod_1.z.unknown(),
+        fieldTypes: ['string', 'number', 'boolean'],
+    },
+    gt: {
+        label: 'Greater Than',
+        category: 'comparison',
+        evaluate: (fieldValue, targetValue) => {
+            if (typeof fieldValue !== 'number' || typeof targetValue !== 'number') {
+                return false;
+            }
+            return fieldValue > targetValue;
+        },
+        schema: zod_1.z.number(),
+        fieldTypes: ['number'],
+    },
+    gte: {
+        label: 'Greater Than or Equal',
+        category: 'comparison',
+        evaluate: (fieldValue, targetValue) => {
+            if (typeof fieldValue !== 'number' || typeof targetValue !== 'number') {
+                return false;
+            }
+            return fieldValue >= targetValue;
+        },
+        schema: zod_1.z.number(),
+        fieldTypes: ['number'],
+    },
+    lt: {
+        label: 'Less Than',
+        category: 'comparison',
+        evaluate: (fieldValue, targetValue) => {
+            if (typeof fieldValue !== 'number' || typeof targetValue !== 'number') {
+                return false;
+            }
+            return fieldValue < targetValue;
+        },
+        schema: zod_1.z.number(),
+        fieldTypes: ['number'],
+    },
+    lte: {
+        label: 'Less Than or Equal',
+        category: 'comparison',
+        evaluate: (fieldValue, targetValue) => {
+            if (typeof fieldValue !== 'number' || typeof targetValue !== 'number') {
+                return false;
+            }
+            return fieldValue <= targetValue;
+        },
+        schema: zod_1.z.number(),
+        fieldTypes: ['number'],
+    },
+    // --- Membership operators ---
+    in: {
+        label: 'In',
+        category: 'membership',
+        evaluate: (fieldValue, targetValue) => {
+            if (!Array.isArray(targetValue)) {
+                return false;
+            }
+            return targetValue.includes(fieldValue);
+        },
+        schema: zod_1.z.array(zod_1.z.unknown()),
+        fieldTypes: ['string', 'number'],
+    },
+    not_in: {
+        label: 'Not In',
+        category: 'membership',
+        evaluate: (fieldValue, targetValue) => {
+            if (!Array.isArray(targetValue)) {
+                return true;
+            }
+            return !targetValue.includes(fieldValue);
+        },
+        schema: zod_1.z.array(zod_1.z.unknown()),
+        fieldTypes: ['string', 'number'],
+    },
+    contains: {
+        label: 'Contains',
+        category: 'membership',
+        evaluate: (fieldValue, targetValue) => {
+            if (Array.isArray(fieldValue)) {
+                return fieldValue.includes(targetValue);
+            }
+            if (typeof fieldValue === 'string' && typeof targetValue === 'string') {
+                return fieldValue.includes(targetValue);
+            }
+            return false;
+        },
+        schema: zod_1.z.unknown(),
+        fieldTypes: ['string', 'array'],
+    },
+    not_contains: {
+        label: 'Not Contains',
+        category: 'membership',
+        evaluate: (fieldValue, targetValue) => {
+            if (Array.isArray(fieldValue)) {
+                return !fieldValue.includes(targetValue);
+            }
+            if (typeof fieldValue === 'string' && typeof targetValue === 'string') {
+                return !fieldValue.includes(targetValue);
+            }
+            return true;
+        },
+        schema: zod_1.z.unknown(),
+        fieldTypes: ['string', 'array'],
+    },
+    // --- Boolean operators ---
+    is_true: {
+        label: 'Is True',
+        category: 'boolean',
+        evaluate: (fieldValue, _targetValue) => {
+            return Boolean(fieldValue);
+        },
+        schema: zod_1.z.unknown().optional(),
+        fieldTypes: ['boolean'],
+    },
+    is_false: {
+        label: 'Is False',
+        category: 'boolean',
+        evaluate: (fieldValue, _targetValue) => {
+            return !fieldValue;
+        },
+        schema: zod_1.z.unknown().optional(),
+        fieldTypes: ['boolean'],
+    },
+};

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { OperatorRegistry } from './operator-registry';
+export { builtInOperators } from './built-in-operators';

package/dist/index.js

@@ -0,0 +1,14 @@
+"use strict";
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.builtInOperators = exports.OperatorRegistry = void 0;
+var operator_registry_1 = require("./operator-registry");
+Object.defineProperty(exports, "OperatorRegistry", { enumerable: true, get: function () { return operator_registry_1.OperatorRegistry; } });
+var built_in_operators_1 = require("./built-in-operators");
+Object.defineProperty(exports, "builtInOperators", { enumerable: true, get: function () { return built_in_operators_1.builtInOperators; } });

package/dist/operator-registry.d.ts

@@ -0,0 +1,35 @@
+import type { OperatorDefinition, OperatorInfo } from '@bernierllc/nevar-types';
+/**
+ * Registry for managing built-in and custom operators.
+ * Provides registration, lookup, discovery, and evaluation capabilities.
+ */
+export declare class OperatorRegistry {
+    private readonly operators;
+    constructor();
+    /**
+     * Register a new operator. Throws NevarValidationError on duplicate name.
+     */
+    register(name: string, definition: OperatorDefinition): void;
+    /**
+     * Get an operator definition by name.
+     */
+    get(name: string): OperatorDefinition | undefined;
+    /**
+     * Check if an operator is registered.
+     */
+    has(name: string): boolean;
+    /**
+     * List all registered operators as serializable OperatorInfo objects.
+     * Excludes the evaluate function.
+     */
+    list(): OperatorInfo[];
+    /**
+     * Get all operators in a given category.
+     */
+    getByCategory(category: string): OperatorInfo[];
+    /**
+     * Evaluate a field value against a target value using the named operator.
+     * Throws NevarEvaluationError for unknown operators.
+     */
+    evaluate(name: string, fieldValue: unknown, targetValue: unknown): boolean;
+}

package/dist/operator-registry.js

@@ -0,0 +1,80 @@
+"use strict";
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperatorRegistry = void 0;
+const nevar_types_1 = require("@bernierllc/nevar-types");
+const built_in_operators_1 = require("./built-in-operators");
+/**
+ * Registry for managing built-in and custom operators.
+ * Provides registration, lookup, discovery, and evaluation capabilities.
+ */
+class OperatorRegistry {
+    operators = new Map();
+    constructor() {
+        // Pre-register all 12 built-in operators
+        for (const [name, definition] of Object.entries(built_in_operators_1.builtInOperators)) {
+            this.operators.set(name, definition);
+        }
+    }
+    /**
+     * Register a new operator. Throws NevarValidationError on duplicate name.
+     */
+    register(name, definition) {
+        if (this.operators.has(name)) {
+            throw new nevar_types_1.NevarValidationError(`Operator "${name}" is already registered`, { code: 'OPERATOR_DUPLICATE', context: { name } });
+        }
+        this.operators.set(name, definition);
+    }
+    /**
+     * Get an operator definition by name.
+     */
+    get(name) {
+        return this.operators.get(name);
+    }
+    /**
+     * Check if an operator is registered.
+     */
+    has(name) {
+        return this.operators.has(name);
+    }
+    /**
+     * List all registered operators as serializable OperatorInfo objects.
+     * Excludes the evaluate function.
+     */
+    list() {
+        const result = [];
+        for (const [name, def] of this.operators) {
+            result.push({
+                name,
+                label: def.label,
+                category: def.category,
+                fieldTypes: def.fieldTypes,
+            });
+        }
+        return result;
+    }
+    /**
+     * Get all operators in a given category.
+     */
+    getByCategory(category) {
+        return this.list().filter((op) => op.category === category);
+    }
+    /**
+     * Evaluate a field value against a target value using the named operator.
+     * Throws NevarEvaluationError for unknown operators.
+     */
+    evaluate(name, fieldValue, targetValue) {
+        const definition = this.operators.get(name);
+        if (!definition) {
+            throw new nevar_types_1.NevarEvaluationError(`Unknown operator "${name}"`, { code: 'OPERATOR_NOT_FOUND', context: { name } });
+        }
+        return definition.evaluate(fieldValue, targetValue);
+    }
+}
+exports.OperatorRegistry = OperatorRegistry;

package/package.json

@@ -1,10 +1,39 @@
 {
   "name": "@bernierllc/nevar-operator-registry",
-  "version": "0.0.1",
-  "description": "OIDC trusted publishing setup package for @bernierllc/nevar-operator-registry",
-  "keywords": [
-    "oidc",
-    "trusted-publishing",
-    "setup"
-  ]
-}
+  "version": "0.1.0",
+  "description": "Operator registry with 12 built-in operators for the Nevar rules engine",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/**/*",
+    "README.md",
+    "LICENSE"
+  ],
+  "author": "Bernier LLC",
+  "license": "SEE LICENSE IN LICENSE",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bernierllc/tools.git",
+    "directory": "packages/core/nevar-operator-registry"
+  },
+  "dependencies": {
+    "zod": "^3.22.0",
+    "@bernierllc/nevar-types": "0.1.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prebuild": "npm run clean",
+    "clean": "rimraf dist",
+    "test": "jest --watch",
+    "test:run": "jest",
+    "test:coverage": "jest --coverage",
+    "lint": "eslint src __tests__ --ext .ts"
+  }
+}