@bernierllc/nevar-mixin-bridge 0.0.1 → 0.1.0

package/README.md

@@ -1,45 +1,105 @@
 # @bernierllc/nevar-mixin-bridge
 
-## ⚠️ IMPORTANT NOTICE ⚠️
-
-**This package is created solely for the purpose of setting up OIDC (OpenID Connect) trusted publishing with npm.**
-
-This is **NOT** a functional package and contains **NO** code or functionality beyond the OIDC setup configuration.
-
-## Purpose
-
-This package exists to:
-1. Configure OIDC trusted publishing for the package name `@bernierllc/nevar-mixin-bridge`
-2. Enable secure, token-less publishing from CI/CD workflows
-3. Establish provenance for packages published under this name
-
-## What is OIDC Trusted Publishing?
-
-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.
-
-## Setup Instructions
-
-To properly configure OIDC trusted publishing for this package:
-
-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
-
-## DO NOT USE THIS PACKAGE
-
-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
-
-## More Information
-
-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)
-
----
-
-**Maintained for OIDC setup purposes only**
+Mixin definition utilities for the Nevar rules engine. Allows domain-specific extensions to register triggers, operators, actions, and context providers onto a Nevar instance under a namespace.
+
+## Installation
+
+```bash
+npm install @bernierllc/nevar-mixin-bridge
+```
+
+## Usage
+
+```typescript
+import { defineMixin } from '@bernierllc/nevar-mixin-bridge';
+import type { MixinDefinition } from '@bernierllc/nevar-mixin-bridge';
+import { z } from 'zod';
+
+const ecommerceMixin = defineMixin('ecommerce', {
+  triggers: [
+    {
+      key: 'order.placed',
+      payloadSchema: z.object({ orderId: z.string(), total: z.number() }),
+      description: 'Fires when an order is placed',
+      category: 'commerce',
+    },
+  ],
+  operators: [
+    {
+      name: 'currency_gt',
+      definition: {
+        label: 'Currency Greater Than',
+        category: 'commerce',
+        evaluate: (field, target) => Number(field) > Number(target),
+        schema: z.number(),
+        fieldTypes: ['number'],
+      },
+    },
+  ],
+  actions: [
+    {
+      actionType: 'send-receipt',
+      definition: {
+        execute: async (config, context) => {
+          // Send receipt logic
+          return { sent: true };
+        },
+      },
+    },
+  ],
+  contextProviders: [
+    {
+      prefix: 'order',
+      provider: async (payload) => ({
+        total: 99.99,
+        currency: 'USD',
+      }),
+    },
+  ],
+  methods: {
+    getOrderStatus: (orderId: string) => 'shipped',
+  },
+});
+
+// Apply to a Nevar instance
+ecommerceMixin(nevar);
+
+// Methods are accessible under the namespace
+// nevar.ecommerce.getOrderStatus('order-1')
+```
+
+## API
+
+### `defineMixin(namespace, definition)`
+
+Creates a mixin function that can be applied to a Nevar instance. The returned function registers all triggers, operators, actions, and context providers defined in the mixin, and mounts any methods at `nevar[namespace]`.
+
+**Parameters:**
+- `namespace: string` - The namespace to mount methods under
+- `definition: MixinDefinition` - The mixin definition containing triggers, operators, actions, context providers, and methods
+
+**Returns:** `(nevar: NevarLike) => void` - A function that applies the mixin to a Nevar instance
+
+**Throws:** `NevarValidationError` if the namespace is already registered on the instance.
+
+### Types
+
+- `MixinDefinition` - Complete mixin definition with optional `triggers`, `operators`, `actions`, `contextProviders`, and `methods`
+- `MixinTrigger` - Trigger definition with `key`, `payloadSchema`, optional `description` and `category`
+- `MixinOperator` - Operator definition with `name` and `definition: OperatorDefinition`
+- `MixinAction` - Action definition with `actionType` and `definition: ActionHandlerDefinition`
+- `MixinContextProvider` - Context provider with `prefix` and `provider` function
+- `ActionHandlerDefinition` - Action handler with `execute` function and optional `description`
+- `NevarLike` - Minimal interface for a Nevar instance that supports registration methods
+
+## 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/define-mixin.d.ts

@@ -0,0 +1,73 @@
+import { OperatorDefinition } from '@bernierllc/nevar-types';
+/**
+ * Definition for an action handler that a mixin can register.
+ */
+export interface ActionHandlerDefinition {
+    execute: (config: Record<string, unknown>, context: Record<string, unknown>) => Promise<Record<string, unknown>>;
+    description?: string;
+}
+/**
+ * A trigger definition within a mixin.
+ */
+export interface MixinTrigger {
+    key: string;
+    payloadSchema: unknown;
+    description?: string;
+    category?: string;
+}
+/**
+ * An operator definition within a mixin.
+ */
+export interface MixinOperator {
+    name: string;
+    definition: OperatorDefinition;
+}
+/**
+ * An action definition within a mixin.
+ */
+export interface MixinAction {
+    actionType: string;
+    definition: ActionHandlerDefinition;
+}
+/**
+ * A context provider definition within a mixin.
+ */
+export interface MixinContextProvider {
+    prefix: string;
+    provider: (payload: Record<string, unknown>) => Promise<Record<string, unknown>> | Record<string, unknown>;
+}
+/**
+ * Complete mixin definition describing triggers, operators, actions,
+ * context providers, and methods to register on a Nevar instance.
+ */
+export interface MixinDefinition {
+    triggers?: MixinTrigger[];
+    operators?: MixinOperator[];
+    actions?: MixinAction[];
+    contextProviders?: MixinContextProvider[];
+    methods?: Record<string, Function>;
+}
+/**
+ * Minimal interface describing a Nevar-like instance that supports
+ * registration of operators, triggers, actions, and context providers.
+ */
+export interface NevarLike {
+    registerOperator(name: string, def: OperatorDefinition): void;
+    registerTrigger(key: string, def: Record<string, unknown>): void;
+    registerAction(type: string, def: ActionHandlerDefinition): void;
+    registerContextProvider(prefix: string, fn: (payload: Record<string, unknown>) => Promise<Record<string, unknown>> | Record<string, unknown>): void;
+    [key: string]: unknown;
+}
+/**
+ * Defines a mixin function that can be applied to a Nevar instance.
+ *
+ * The returned function will:
+ * 1. Check for namespace conflicts on the Nevar instance
+ * 2. Register all triggers, operators, actions, and context providers
+ * 3. Mount any methods at `nevar[namespace]`
+ *
+ * @param namespace - The namespace to mount methods under
+ * @param definition - The mixin definition
+ * @returns A function that applies the mixin to a NevarLike instance
+ */
+export declare function defineMixin(namespace: string, definition: MixinDefinition): (nevar: NevarLike) => void;

package/dist/define-mixin.js

@@ -0,0 +1,60 @@
+"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.defineMixin = defineMixin;
+const nevar_types_1 = require("@bernierllc/nevar-types");
+/**
+ * Defines a mixin function that can be applied to a Nevar instance.
+ *
+ * The returned function will:
+ * 1. Check for namespace conflicts on the Nevar instance
+ * 2. Register all triggers, operators, actions, and context providers
+ * 3. Mount any methods at `nevar[namespace]`
+ *
+ * @param namespace - The namespace to mount methods under
+ * @param definition - The mixin definition
+ * @returns A function that applies the mixin to a NevarLike instance
+ */
+function defineMixin(namespace, definition) {
+    return (nevar) => {
+        // Check for namespace conflict
+        if (nevar[namespace] !== undefined) {
+            throw new nevar_types_1.NevarValidationError(`Mixin namespace "${namespace}" is already registered on this Nevar instance`, {
+                code: 'NEVAR_MIXIN_NAMESPACE_CONFLICT',
+                context: { namespace },
+            });
+        }
+        if (definition.triggers) {
+            for (const trigger of definition.triggers) {
+                nevar.registerTrigger(trigger.key, {
+                    key: trigger.key,
+                    description: trigger.description,
+                    schema: trigger.payloadSchema,
+                    metadata: trigger.category ? { category: trigger.category } : undefined,
+                });
+            }
+        }
+        if (definition.operators) {
+            for (const operator of definition.operators) {
+                nevar.registerOperator(operator.name, operator.definition);
+            }
+        }
+        if (definition.actions) {
+            for (const action of definition.actions) {
+                nevar.registerAction(action.actionType, action.definition);
+            }
+        }
+        if (definition.contextProviders) {
+            for (const cp of definition.contextProviders) {
+                nevar.registerContextProvider(cp.prefix, cp.provider);
+            }
+        }
+        nevar[namespace] = { ...definition.methods };
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { defineMixin } from './define-mixin';
+export type { MixinDefinition, MixinTrigger, MixinOperator, MixinAction, MixinContextProvider, ActionHandlerDefinition, NevarLike, } from './define-mixin';

package/dist/index.js

@@ -0,0 +1,12 @@
+"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.defineMixin = void 0;
+var define_mixin_1 = require("./define-mixin");
+Object.defineProperty(exports, "defineMixin", { enumerable: true, get: function () { return define_mixin_1.defineMixin; } });

package/package.json

@@ -1,10 +1,56 @@
 {
   "name": "@bernierllc/nevar-mixin-bridge",
-  "version": "0.0.1",
-  "description": "OIDC trusted publishing setup package for @bernierllc/nevar-mixin-bridge",
+  "version": "0.1.0",
+  "description": "Utilities for building withX() mixin functions for the Nevar rules engine",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/**/*",
+    "README.md",
+    "LICENSE"
+  ],
   "keywords": [
-    "oidc",
-    "trusted-publishing",
-    "setup"
-  ]
-}
+    "nevar",
+    "rules-engine",
+    "mixin",
+    "mixin-bridge",
+    "plugin"
+  ],
+  "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-mixin-bridge"
+  },
+  "dependencies": {
+    "@bernierllc/nevar-types": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.0",
+    "@types/node": "^20.0.0",
+    "@typescript-eslint/eslint-plugin": "^6.0.0",
+    "@typescript-eslint/parser": "^6.0.0",
+    "eslint": "^8.0.0",
+    "jest": "^29.5.0",
+    "rimraf": "^5.0.0",
+    "ts-jest": "^29.1.0",
+    "typescript": "^5.0.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prebuild": "npm run clean",
+    "clean": "rimraf dist",
+    "test": "jest",
+    "test:run": "jest",
+    "test:coverage": "jest --coverage",
+    "lint": "eslint src __tests__ --ext .ts"
+  }
+}