@friggframework/schemas 2.0.0--canary.701.00d6b2c.0 → 2.0.0--canary.689.f2e7e1d.0

package/README.md

@@ -146,9 +146,7 @@ Defines the structure for Frigg API modules.
 **Key Properties:**
 - `moduleName` (required): Module identifier
 - `getName` (required): Function returning module name
-- `requiredAuthMethods` (required): Authentication configuration (includes optional `getAuthorizationRequirements` and `setAuthParams` for API-key modules)
-- `modelName`: Entity/credential model name used by the Module runtime
-- Real Definitions (classes/functions) are accepted by `validateApiModuleDefinition` via a schema view.
+- `requiredAuthMethods` (required): Authentication configuration
 - `env`: Environment variable configuration
 - `config`: Module-specific configuration
 

package/index.js

@@ -12,9 +12,6 @@ const path = require('path');
 
 // Import middleware
 const schemaValidationMiddleware = require('./middleware/schema-validation');
-const {
-    toApiModuleDefinitionSchemaView,
-} = require('./api-module-definition');
 
 // Initialize AJV with formats
 const ajv = new Ajv({ 
@@ -92,18 +89,12 @@ function validateIntegrationDefinition(integrationDefinition) {
 }
 
 /**
- * Validate API Module Definition.
- * Real Definitions carry classes and functions; validate the serialisable
- * view and return the original definition.
- * @param {object} apiModuleDefinition - API module definition object to validate
+ * Validate API Module Definition
+ * @param {object} apiModuleDefinition - API module definition object to validate  
  * @returns {object} - Validation result
  */
 function validateApiModuleDefinition(apiModuleDefinition) {
-    const result = validate(
-        'api-module-definition',
-        toApiModuleDefinitionSchemaView(apiModuleDefinition)
-    );
-    return { ...result, data: apiModuleDefinition };
+    return validate('api-module-definition', apiModuleDefinition);
 }
 
 /**
@@ -366,7 +357,6 @@ module.exports = {
     // Validation functions
     validate,
     validateAppDefinition,
-    toApiModuleDefinitionSchemaView,
     validateIntegrationDefinition,
     validateApiModuleDefinition,
     validateServerlessConfig,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@friggframework/schemas",
-  "version": "2.0.0--canary.701.00d6b2c.0",
+  "version": "2.0.0--canary.689.f2e7e1d.0",
   "description": "Canonical JSON Schema definitions for Frigg Framework",
   "main": "index.js",
   "author": "",
@@ -39,8 +39,7 @@
     "validators/",
     "mocks/",
     "middleware/",
-    "api-module-definition.js",
     "index.js"
   ],
-  "gitHead": "00d6b2c41f32118d4dbde57f8dfe3c6416840992"
+  "gitHead": "f2e7e1d56cdcc9d6a267ff02714ad8fdad86051f"
 }

package/schemas/api-module-definition.schema.json

@@ -27,13 +27,6 @@
       "minLength": 1,
       "maxLength": 100
     },
-    "modelName": {
-      "type": "string",
-      "description": "Entity/credential model name used by the Module runtime (e.g. 'Fathom'). Distinct from moduleName, which is the package identifier.",
-      "pattern": "^[a-zA-Z][a-zA-Z0-9_]*$",
-      "minLength": 1,
-      "maxLength": 100
-    },
     "requiredAuthMethods": {
       "type": "object",
       "description": "Required authentication methods and configuration",
@@ -97,22 +90,6 @@
             "type": {"type": "string", "enum": ["function"]},
             "async": {"type": "boolean", "default": true}
           }
-        },
-        "getAuthorizationRequirements": {
-          "type": "object",
-          "description": "Method that returns the authorization requirements (type, jsonSchema/uiSchema) for non-OAuth flows such as API key",
-          "properties": {
-            "type": {"type": "string", "enum": ["function"]},
-            "async": {"type": "boolean", "default": true}
-          }
-        },
-        "setAuthParams": {
-          "type": "object",
-          "description": "Method that applies authorization parameters (e.g. API key) to the API instance",
-          "properties": {
-            "type": {"type": "string", "enum": ["function"]},
-            "async": {"type": "boolean", "default": true}
-          }
         }
       },
       "additionalProperties": false

package/api-module-definition.js

@@ -1,93 +0,0 @@
-/**
- * API module definition helpers shared by validators and the frigg CLI.
- * Real Definitions carry classes and functions that JSON Schema cannot
- * describe; validators check the serialisable view produced here.
- */
-
-function isPlainObject(value) {
-    if (value === null || typeof value !== 'object') return false;
-    const proto = Object.getPrototypeOf(value);
-    return proto === Object.prototype || proto === null;
-}
-
-/**
- * Schema descriptor for a JavaScript function (see api-module-definition
- * schema: `{ type: "function", async?: boolean }`).
- *
- * @param {Function} fn
- * @returns {{ type: 'function', async?: boolean }}
- */
-function toFunctionDescriptor(fn) {
-    const descriptor = { type: 'function' };
-    if (fn && fn.constructor && fn.constructor.name === 'AsyncFunction') {
-        descriptor.async = true;
-    }
-    return descriptor;
-}
-
-/**
- * JSON Schema cannot describe a JavaScript class or function. Validators
- * therefore check this serialisable view: the API class becomes an empty
- * object, functions become `{ type: "function" }` descriptors, and
- * `undefined` env values are dropped (unset `process.env.*` entries).
- *
- * @param {object} definition the `Definition` exported by an API module
- * @returns {object} a view suitable for the api-module-definition schema
- */
-function toApiModuleDefinitionSchemaView(definition) {
-    if (!isPlainObject(definition)) return definition;
-
-    const view = { ...definition };
-
-    if (typeof view.API === 'function') {
-        view.API = {};
-    }
-
-    if (typeof view.getName === 'function') {
-        view.getName = toFunctionDescriptor(view.getName);
-    }
-
-    if (isPlainObject(view.requiredAuthMethods)) {
-        const methods = { ...view.requiredAuthMethods };
-        for (const [key, value] of Object.entries(methods)) {
-            if (typeof value === 'function') {
-                methods[key] = toFunctionDescriptor(value);
-            }
-        }
-        view.requiredAuthMethods = methods;
-    }
-
-    if (isPlainObject(view.env)) {
-        const env = {};
-        for (const [key, value] of Object.entries(view.env)) {
-            if (value !== undefined) env[key] = value;
-        }
-        view.env = env;
-    }
-
-    if (isPlainObject(view.manager)) {
-        const manager = { ...view.manager };
-        for (const key of ['Entity', 'Credential']) {
-            if (typeof manager[key] === 'function') {
-                manager[key] = {};
-            }
-        }
-        if (isPlainObject(manager.methods)) {
-            const methods = { ...manager.methods };
-            for (const [key, value] of Object.entries(methods)) {
-                if (typeof value === 'function') {
-                    methods[key] = {};
-                }
-            }
-            manager.methods = methods;
-        }
-        view.manager = manager;
-    }
-
-    return view;
-}
-
-module.exports = {
-    toApiModuleDefinitionSchemaView,
-    toFunctionDescriptor,
-};