@friggframework/core 2.0.0--canary.707.df80bfd.0 → 2.0.0--canary.680.d670696.0

package/modules/module.js

@@ -21,17 +21,8 @@ class Module extends Delegate {
      * @param {string} params.userId The user id
      * @param {Object} params.entity The entity record from the database
      * @param {string} [params.state] Optional OAuth state value forwarded to the API client (round-trips through the OAuth provider).
-     * @param {Object} [params.resolvedEnv] definition.env as Module.create() resolved it (may be undefined).
-     * @param {boolean} [params.envResolved=false] true when resolvedEnv carries the resolved env, even an undefined one; otherwise the static definition.env is used.
      */
-    constructor({
-        definition,
-        userId = null,
-        entity: entityObj = null,
-        state = null,
-        resolvedEnv,
-        envResolved = false,
-    }) {
+    constructor({ definition, userId = null, entity: entityObj = null, state = null }) {
         super({ definition, userId, entity: entityObj });
 
         this.validateDefinition(definition);
@@ -63,23 +54,8 @@ class Module extends Delegate {
 
         Object.assign(this, this.definition.requiredAuthMethods);
 
-        // A pre-resolved env (Module.create()) supports definition.env as an
-        // async function, e.g. OAuth app credentials loaded from the database
-        // by the db-credentials extension; otherwise the static object.
-        // "Resolved" is an explicit flag, not a non-null value: a function env
-        // may legitimately resolve to undefined (no static env, no DB row),
-        // and falling back to definition.env would then read the function.
-        const envValues = envResolved ? resolvedEnv : this.definition.env;
-        if (typeof envValues === 'function') {
-            // Spreading a function yields no keys, so the API client would
-            // silently get no client_id / client_secret.
-            throw new TypeError(
-                `Module ${this.name}: definition.env is a function; build the module with await Module.create(...)`
-            );
-        }
-
         const apiParams = {
-            ...envValues,
+            ...this.definition.env,
             delegate: this,
             logger: this.logger,
             ...(state ? { state } : {}),
@@ -91,33 +67,6 @@ class Module extends Delegate {
         this.api = new this.apiClass(apiParams);
     }
 
-    /**
-     * Resolves definition.env, supporting both a static object and a
-     * (possibly async) function.
-     *
-     * @param {Object} definition - Module definition
-     * @returns {Promise<Object|undefined>} Resolved env values
-     */
-    static async resolveEnv(definition) {
-        if (typeof definition.env === 'function') {
-            return await definition.env();
-        }
-        return definition.env;
-    }
-
-    /**
-     * Async factory that resolves definition.env first, so a module whose
-     * env is a function gets its values. Prefer it over `new Module(...)`
-     * wherever the call site can await.
-     *
-     * @param {Object} params - same as the constructor, minus resolvedEnv
-     * @returns {Promise<Module>}
-     */
-    static async create({ definition, userId = null, entity = null, state = null }) {
-        const resolvedEnv = await Module.resolveEnv(definition);
-        return new Module({ definition, userId, entity, state, resolvedEnv, envResolved: true });
-    }
-
     getName() {
         return this.name;
     }

package/modules/proxy/proxy-errors.js

@@ -17,15 +17,4 @@ class ProxyRequestError extends Error {
     }
 }
 
-/**
- * A module definition or the app's proxy settings are wrong. Thrown at load,
- * so the app stops starting instead of failing on the first proxied call.
- */
-class ProxyConfigError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'ProxyConfigError';
-    }
-}
-
-module.exports = { ProxyRequestError, ProxyConfigError };
+module.exports = { ProxyRequestError };

package/modules/proxy/proxy-path.js

@@ -1,5 +1,4 @@
 const { ProxyRequestError } = require('./proxy-errors');
-const { DEFAULT_BASE, ruleBase } = require('./proxy-bases');
 
 /**
  * Path rules for the entity proxy (ADR-052 §4). The caller supplies a path
@@ -134,7 +133,7 @@ function joinProxyUrl(baseUrl, normalizedPath) {
 }
 
 /**
- * Finds the allow-list rule that permits `method` on `path` of `base`.
+ * Finds the allow-list rule that permits `method` on `path`.
  *
  * Patterns use `:param` for exactly one segment and a trailing `/**` for a
  * subtree (the prefix itself included). `method: '*'` matches any method.
@@ -142,17 +141,14 @@ function joinProxyUrl(baseUrl, normalizedPath) {
  * @param {Array<{method: string, path: string}>} rules
  * @param {string} method - upper case
  * @param {string} path - normalised path
- * @param {string} [base='default'] - the named base the request targets; a
- *   rule applies to its own `base` only (no `base` means `default`)
- * @returns {{method: string, path: string, base?: string}|null}
+ * @returns {{method: string, path: string}|null}
  */
-function matchAllowRule(rules, method, path, base = DEFAULT_BASE) {
+function matchAllowRule(rules, method, path) {
     const requestSegments = path.split('/').slice(1);
     for (const rule of rules || []) {
         if (!rule || typeof rule.path !== 'string' || typeof rule.method !== 'string') {
             continue;
         }
-        if (ruleBase(rule) !== base) continue;
         const ruleMethod = rule.method.toUpperCase();
         if (ruleMethod !== '*' && ruleMethod !== method) continue;
         if (patternMatches(rule.path, requestSegments)) return rule;

package/modules/proxy/proxy-policy.js

@@ -1,5 +1,4 @@
 const { ProxyRequestError } = require('./proxy-errors');
-const { isValidBaseName } = require('./proxy-bases');
 
 /**
  * What the entity proxy accepts and returns (ADR-052 §5-§7). Pure functions:
@@ -53,13 +52,6 @@ const REMOVED_RESPONSE_HEADERS = [
 const invalid = (message, details) =>
     new ProxyRequestError('INVALID_PROXY_REQUEST', message, details);
 
-/**
- * A query key ending in `[]` is sent as one `key=value` pair per array
- * element; the requester applies the same rule (see
- * `_rawRequest` in requester.js).
- */
-const isRepeatedQueryKey = (key) => key.endsWith('[]');
-
 const isPlainObject = (value) =>
     value !== null && typeof value === 'object' && !Array.isArray(value);
 
@@ -69,7 +61,7 @@ const isPlainObject = (value) =>
  *
  * @param {unknown} request
  * @param {{ maxRequestBytes: number }} limits
- * @returns {{ method: string, path: string, base?: string, query?: Object, headers: Object, body?: string, requestBytes: number, bodyIsJson: boolean }}
+ * @returns {{ method: string, path: string, query?: Object, headers: Object, body?: string, requestBytes: number, bodyIsJson: boolean }}
  */
 function validateProxyRequest(request, { maxRequestBytes }) {
     if (!isPlainObject(request)) throw invalid('The proxy request must be a JSON object');
@@ -81,19 +73,6 @@ function validateProxyRequest(request, { maxRequestBytes }) {
         throw invalid('path is required', { field: 'path' });
     }
 
-    // `base` is a name, never a URL or host; anything else is refused before
-    // a module is looked up. Omitted means `default` (the caller applies it).
-    let base;
-    if (request.base !== undefined && request.base !== null) {
-        if (typeof request.base !== 'string' || !isValidBaseName(request.base)) {
-            throw invalid(
-                'base must be the name of one of the module\'s base URLs (lower case letters, digits and -), not a URL or host',
-                { field: 'base' }
-            );
-        }
-        base = request.base;
-    }
-
     let query;
     if (request.query !== undefined && request.query !== null) {
         if (!isPlainObject(request.query)) throw invalid('query must be an object', { field: 'query' });
@@ -106,13 +85,8 @@ function validateProxyRequest(request, { maxRequestBytes }) {
                     field: `query.${key}`,
                 });
             }
-            // A key ending in `[]` (`fields[]`) is sent once per value, as
-            // Airtable and Fathom expect; every other array goes comma-separated.
-            if (list) {
-                query[key] = isRepeatedQueryKey(key) ? [...value] : value.join(',');
-            } else {
-                query[key] = value;
-            }
+            // The requester sends one value per key; arrays go comma-separated.
+            query[key] = list ? value.join(',') : value;
         }
     }
 
@@ -147,19 +121,16 @@ function validateProxyRequest(request, { maxRequestBytes }) {
             `The proxied request body is larger than ${maxRequestBytes} bytes`
         );
     }
-    return { method, path: request.path, ...(base !== undefined && { base }), query, headers, body, bodyIsJson, requestBytes };
+    return { method, path: request.path, query, headers, body, bodyIsJson, requestBytes };
 }
 
 const isWildcardRule = (rule) => rule?.method === '*' || rule?.path === '/**';
 
-// A rule's `base` is checked against the module's declared bases at load, by
-// assertProxyConfig (proxy-bases.js); here only its shape is.
 const isValidRule = (rule) =>
     isPlainObject(rule) &&
     typeof rule.method === 'string' &&
     typeof rule.path === 'string' &&
-    rule.path.startsWith('/') &&
-    (rule.base === undefined || isValidBaseName(rule.base));
+    rule.path.startsWith('/');
 
 /**
  * The allow-list in force for a module: the app definition's list for it when

package/modules/repositories/module-repository-documentdb.js

@@ -3,14 +3,12 @@ const {
     toObjectId,
     fromObjectId,
     findMany,
-    findManyDrained,
     findOne,
     insertOne,
     updateOne,
     deleteOne,
 } = require('../../database/documentdb-utils');
 const { ModuleRepositoryInterface } = require('./module-repository-interface');
-const { entityNotFoundError } = require('./entity-not-found');
 const { DocumentDBEncryptionService } = require('../../database/documentdb-encryption-service');
 
 /**
@@ -35,11 +33,11 @@ class ModuleRepositoryDocumentDB extends ModuleRepositoryInterface {
     async findEntityById(entityId) {
         const objectId = toObjectId(entityId);
         if (!objectId) {
-            throw entityNotFoundError(entityId);
+            throw new Error(`Entity ${entityId} not found`);
         }
         const doc = await findOne(this.prisma, 'Entity', { _id: objectId });
         if (!doc) {
-            throw entityNotFoundError(entityId);
+            throw new Error(`Entity ${entityId} not found`);
         }
         const credential = await this._fetchCredential(doc.credentialId);
         return this._mapEntity(doc, credential);
@@ -78,29 +76,6 @@ class ModuleRepositoryDocumentDB extends ModuleRepositoryInterface {
         return docs.map((doc) => this._mapEntity(doc, credentialMap.get(fromObjectId(doc.credentialId)) || null));
     }
 
-    /**
-     * Find entities matching any of the owner/organization pairs, in one query.
-     * `organizationId: null` matches rows with no organization (a raw MongoDB
-     * `null` also matches a missing field). The caller (a use case) decides
-     * which pairs; this only runs them.
-     *
-     * @param {Array<{userId: string, organizationId: (string|null)}>} clauses
-     * @returns {Promise<Array>}
-     */
-    async findEntitiesByOwnership(clauses) {
-        if (!Array.isArray(clauses) || clauses.length === 0) return [];
-        // Drained: a list can hold more than the first cursor batch (~101).
-        const docs = await findManyDrained(this.prisma, 'Entity', {
-            $or: clauses.map(({ userId, organizationId }) => ({
-                userId: toObjectId(userId),
-                organizationId:
-                    organizationId === null ? null : toObjectId(organizationId),
-            })),
-        });
-        const credentialMap = await this._fetchCredentialsBulk(docs.map((doc) => doc.credentialId));
-        return docs.map((doc) => this._mapEntity(doc, credentialMap.get(fromObjectId(doc.credentialId)) || null));
-    }
-
     async unsetCredential(entityId) {
         const objectId = toObjectId(entityId);
         if (!objectId) return false;
@@ -140,14 +115,7 @@ class ModuleRepositoryDocumentDB extends ModuleRepositoryInterface {
         );
     }
 
-    /**
-     * @param {Object} entityData
-     * @param {{organizationId?: (string|null)}} [tenancy] - the organization the entity
-     *   belongs to (ADR-056 §3.6). A separate argument, not a field of `entityData`,
-     *   because `entityData` carries provider fields and one named `organizationId`
-     *   must not be taken for ours.
-     */
-    async createEntity(entityData, tenancy = {}) {
+    async createEntity(entityData) {
         const {
             user,
             userId,
@@ -165,7 +133,6 @@ class ModuleRepositoryDocumentDB extends ModuleRepositoryInterface {
             name: name ?? null,
             moduleName: moduleName ?? null,
             externalId: externalId ?? null,
-            organizationId: toObjectId(tenancy.organizationId) || null,
             data: dynamicData,
         };
         const insertedId = await insertOne(this.prisma, 'Entity', document);
@@ -280,9 +247,8 @@ class ModuleRepositoryDocumentDB extends ModuleRepositoryInterface {
             const objectIds = ids.map(id => toObjectId(id)).filter(Boolean);
             if (objectIds.length === 0) return new Map();
 
-            // Raw read to bypass the Prisma encryption extension. Drained:
-            // more ids than the first cursor batch must all come back.
-            const rawCredentials = await findManyDrained(this.prisma, 'Credential', {
+            // Use raw findMany to bypass Prisma encryption extension
+            const rawCredentials = await findMany(this.prisma, 'Credential', {
                 _id: { $in: objectIds }
             });
 
@@ -363,30 +329,19 @@ class ModuleRepositoryDocumentDB extends ModuleRepositoryInterface {
         if (filter.name) query.name = filter.name;
         if (filter.moduleName) query.moduleName = filter.moduleName;
         if (filter.externalId) query.externalId = filter.externalId;
-        // `null` means "no organization"; absent means "any". A raw MongoDB
-        // `{ field: null }` matches both a null value and a missing field.
-        if (filter.organizationId !== undefined) {
-            query.organizationId =
-                filter.organizationId === null
-                    ? null
-                    : toObjectId(filter.organizationId);
-        }
         return query;
     }
 
     _mapEntity(doc, credential) {
         const dynamicData = doc?.data || {};
         return {
-            // First, so no stored provider field can replace a column below
-            // (identity, owner or organization decide who sees the entity).
-            ...dynamicData,
             id: fromObjectId(doc?._id),
             credential,
             userId: fromObjectId(doc?.userId),
             name: doc?.name ?? null,
             externalId: doc?.externalId ?? null,
             moduleName: doc?.moduleName ?? null,
-            organizationId: fromObjectId(doc?.organizationId) ?? null,
+            ...dynamicData,
         };
     }
 }

package/modules/repositories/module-repository-interface.js

@@ -67,21 +67,6 @@ class ModuleRepositoryInterface {
         );
     }
 
-    /**
-     * Find entities matching any of the owner/organization pairs, in one query
-     * (ADR-056 §3.6). `organizationId: null` matches rows with no organization.
-     * Which pairs is decided by the caller (modules/entity-scope.js), not here.
-     *
-     * @param {Array<{userId: string|number, organizationId: (string|number|null)}>} clauses
-     * @returns {Promise<Array>} Array of entity objects
-     * @abstract
-     */
-    async findEntitiesByOwnership(clauses) {
-        throw new Error(
-            'Method findEntitiesByOwnership must be implemented by subclass'
-        );
-    }
-
     /**
      * Unset credential from entity
      *
@@ -125,13 +110,11 @@ class ModuleRepositoryInterface {
     /**
      * Create a new entity
      *
-     * @param {Object} entityData - Entity data (provider fields included)
-     * @param {{organizationId?: (string|number|null)}} [tenancy] - the organization
-     *   the entity belongs to (ADR-056 §3.6), kept apart from `entityData`
+     * @param {Object} entityData - Entity data
      * @returns {Promise<Object>} Created entity object
      * @abstract
      */
-    async createEntity(entityData, tenancy) {
+    async createEntity(entityData) {
         throw new Error('Method createEntity must be implemented by subclass');
     }
 

package/modules/repositories/module-repository-mongo.js

@@ -1,7 +1,5 @@
 const { prisma } = require('../../database/prisma');
-const { organizationWhere } = require('../../database/organization-where');
 const { ModuleRepositoryInterface } = require('./module-repository-interface');
-const { entityNotFoundError } = require('./entity-not-found');
 
 /**
  * MongoDB Module Repository Adapter
@@ -78,26 +76,6 @@ class ModuleRepositoryMongo extends ModuleRepositoryInterface {
         return credentialMap;
     }
 
-    /**
-     * The one place a stored entity row becomes the entity the application sees.
-     * The provider's `data` is spread FIRST and every column is pinned after it:
-     * a stored `id`, `userId` or `organizationId` in `data` must not decide who
-     * owns the entity or who sees it.
-     * @private
-     */
-    _mapEntity(row, credential) {
-        return {
-            ...(row.data || {}),
-            id: row.id,
-            credential,
-            userId: row.userId,
-            name: row.name,
-            externalId: row.externalId,
-            moduleName: row.moduleName,
-            organizationId: row.organizationId ?? null,
-        };
-    }
-
     /**
      * Find entity by ID with credential
      * Replaces: Entity.findById(entityId).populate('credential')
@@ -112,12 +90,20 @@ class ModuleRepositoryMongo extends ModuleRepositoryInterface {
         });
 
         if (!entity) {
-            throw entityNotFoundError(entityId);
+            throw new Error(`Entity ${entityId} not found`);
         }
 
         const credential = await this._fetchCredential(entity.credentialId);
 
-        return this._mapEntity(entity, credential);
+        return {
+            id: entity.id,
+            credential,
+            userId: entity.userId,
+            name: entity.name,
+            externalId: entity.externalId,
+            moduleName: entity.moduleName,
+            ...(entity.data || {}),
+        };
     }
 
     /**
@@ -135,7 +121,15 @@ class ModuleRepositoryMongo extends ModuleRepositoryInterface {
         const credentialIds = entities.map(e => e.credentialId).filter(Boolean);
         const credentialMap = await this._fetchCredentialsBulk(credentialIds);
 
-        return entities.map((e) => (this._mapEntity(e, credentialMap.get(e.credentialId) || null)));
+        return entities.map((e) => ({
+            id: e.id,
+            credential: credentialMap.get(e.credentialId) || null,
+            userId: e.userId,
+            name: e.name,
+            externalId: e.externalId,
+            moduleName: e.moduleName,
+            ...(e.data || {}),
+        }));
     }
 
     /**
@@ -153,7 +147,15 @@ class ModuleRepositoryMongo extends ModuleRepositoryInterface {
         const credentialIds = entities.map(e => e.credentialId).filter(Boolean);
         const credentialMap = await this._fetchCredentialsBulk(credentialIds);
 
-        return entities.map((e) => (this._mapEntity(e, credentialMap.get(e.credentialId) || null)));
+        return entities.map((e) => ({
+            id: e.id,
+            credential: credentialMap.get(e.credentialId) || null,
+            userId: e.userId,
+            name: e.name,
+            externalId: e.externalId,
+            moduleName: e.moduleName,
+            ...(e.data || {}),
+        }));
     }
 
     /**
@@ -175,32 +177,15 @@ class ModuleRepositoryMongo extends ModuleRepositoryInterface {
         const credentialIds = entities.map(e => e.credentialId).filter(Boolean);
         const credentialMap = await this._fetchCredentialsBulk(credentialIds);
 
-        return entities.map((e) => (this._mapEntity(e, credentialMap.get(e.credentialId) || null)));
-    }
-
-    /**
-     * Find entities matching any of the owner/organization pairs, in one query.
-     * `organizationId: null` matches rows with no organization. The caller
-     * (a use case) decides which pairs; this only runs them.
-     *
-     * @param {Array<{userId: string, organizationId: (string|null)}>} clauses
-     * @returns {Promise<Array>} Array of entity objects with string IDs
-     */
-    async findEntitiesByOwnership(clauses) {
-        if (!Array.isArray(clauses) || clauses.length === 0) return [];
-        const entities = await this.prisma.entity.findMany({
-            where: {
-                OR: clauses.map(({ userId, organizationId }) => ({
-                    userId,
-                    ...organizationWhere(organizationId),
-                })),
-            },
-        });
-
-        const credentialIds = entities.map(e => e.credentialId).filter(Boolean);
-        const credentialMap = await this._fetchCredentialsBulk(credentialIds);
-
-        return entities.map((e) => (this._mapEntity(e, credentialMap.get(e.credentialId) || null)));
+        return entities.map((e) => ({
+            id: e.id,
+            credential: credentialMap.get(e.credentialId) || null,
+            userId: e.userId,
+            name: e.name,
+            externalId: e.externalId,
+            moduleName: e.moduleName,
+            ...(e.data || {}),
+        }));
     }
 
     /**
@@ -238,7 +223,15 @@ class ModuleRepositoryMongo extends ModuleRepositoryInterface {
 
         const credential = await this._fetchCredential(entity.credentialId);
 
-        return this._mapEntity(entity, credential);
+        return {
+            id: entity.id,
+            credential,
+            userId: entity.userId,
+            name: entity.name,
+            externalId: entity.externalId,
+            moduleName: entity.moduleName,
+            ...(entity.data || {}),
+        };
     }
 
     /**
@@ -258,7 +251,15 @@ class ModuleRepositoryMongo extends ModuleRepositoryInterface {
             .filter(Boolean);
         const credentialMap = await this._fetchCredentialsBulk(credentialIds);
 
-        return entities.map((e) => (this._mapEntity(e, credentialMap.get(e.credentialId) || null)));
+        return entities.map((e) => ({
+            id: e.id,
+            credential: credentialMap.get(e.credentialId) || null,
+            userId: e.userId,
+            name: e.name,
+            externalId: e.externalId,
+            moduleName: e.moduleName,
+            ...(e.data || {}),
+        }));
     }
 
     /**
@@ -266,13 +267,9 @@ class ModuleRepositoryMongo extends ModuleRepositoryInterface {
      * Replaces: Entity.create(entityData)
      *
      * @param {Object} entityData - Entity data
-     * @param {{organizationId?: (string|null)}} [tenancy] - the organization the entity
-     *   belongs to (ADR-056 §3.6). A separate argument, not a field of `entityData`,
-     *   because `entityData` carries provider fields and one named `organizationId`
-     *   must not be taken for ours.
      * @returns {Promise<Object>} Created entity object with string IDs
      */
-    async createEntity(entityData, tenancy = {}) {
+    async createEntity(entityData) {
         const {
             user,
             userId,
@@ -290,7 +287,6 @@ class ModuleRepositoryMongo extends ModuleRepositoryInterface {
             name,
             moduleName,
             externalId,
-            organizationId: tenancy.organizationId ?? null,
             data: dynamicData,
         };
 
@@ -300,7 +296,15 @@ class ModuleRepositoryMongo extends ModuleRepositoryInterface {
 
         const credentialObj = await this._fetchCredential(entity.credentialId);
 
-        return this._mapEntity(entity, credentialObj);
+        return {
+            id: entity.id,
+            credential: credentialObj,
+            userId: entity.userId,
+            name: entity.name,
+            externalId: entity.externalId,
+            moduleName: entity.moduleName,
+            ...(entity.data || {}),
+        };
     }
 
     /**
@@ -354,7 +358,15 @@ class ModuleRepositoryMongo extends ModuleRepositoryInterface {
 
             const credentialObj = await this._fetchCredential(entity.credentialId);
 
-            return this._mapEntity(entity, credentialObj);
+            return {
+                id: entity.id,
+                credential: credentialObj,
+                userId: entity.userId,
+                name: entity.name,
+                externalId: entity.externalId,
+                moduleName: entity.moduleName,
+                ...(entity.data || {}),
+            };
         } catch (error) {
             if (error.code === 'P2025') {
                 return null;
@@ -417,11 +429,6 @@ class ModuleRepositoryMongo extends ModuleRepositoryInterface {
         if (filter.moduleName) where.moduleName = filter.moduleName;
         if (filter.externalId) where.externalId = this._toString(filter.externalId);
 
-        // `null` means "no organization"; absent means "any".
-        if (filter.organizationId !== undefined) {
-            Object.assign(where, organizationWhere(filter.organizationId));
-        }
-
         return where;
     }
 }