@friggframework/core 2.0.0--canary.684.0da024b.0 → 2.0.0--canary.679.a2bcc2f.0

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

@@ -108,26 +108,6 @@ class ModuleRepositoryPostgres 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.toString(),
-            credential,
-            userId: row.userId?.toString(),
-            name: row.name,
-            externalId: row.externalId,
-            moduleName: row.moduleName,
-            organizationId: row.organizationId?.toString() ?? null,
-        };
-    }
-
     /**
      * Find entity by ID with credential
      * Replaces: Entity.findById(entityId).populate('credential')
@@ -149,7 +129,15 @@ class ModuleRepositoryPostgres extends ModuleRepositoryInterface {
 
         const credential = await this._fetchCredential(entity.credentialId);
 
-        return this._mapEntity(entity, credential);
+        return {
+            id: entity.id.toString(),
+            credential,
+            userId: entity.userId?.toString(),
+            name: entity.name,
+            externalId: entity.externalId,
+            moduleName: entity.moduleName,
+            ...(entity.data || {}),
+        };
     }
 
     /**
@@ -169,7 +157,15 @@ class ModuleRepositoryPostgres 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.toString(),
+            credential: credentialMap.get(e.credentialId) || null,
+            userId: e.userId?.toString(),
+            name: e.name,
+            externalId: e.externalId,
+            moduleName: e.moduleName,
+            ...(e.data || {}),
+        }));
     }
 
     /**
@@ -189,7 +185,15 @@ class ModuleRepositoryPostgres 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.toString(),
+            credential: credentialMap.get(e.credentialId) || null,
+            userId: e.userId?.toString(),
+            name: e.name,
+            externalId: e.externalId,
+            moduleName: e.moduleName,
+            ...(e.data || {}),
+        }));
     }
 
     /**
@@ -213,32 +217,15 @@ class ModuleRepositoryPostgres 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: this._convertId(userId),
-                    organizationId: this._convertId(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.toString(),
+            credential: credentialMap.get(e.credentialId) || null,
+            userId: e.userId?.toString(),
+            name: e.name,
+            externalId: e.externalId,
+            moduleName: e.moduleName,
+            ...(e.data || {}),
+        }));
     }
 
     /**
@@ -277,7 +264,15 @@ class ModuleRepositoryPostgres extends ModuleRepositoryInterface {
 
         const credential = await this._fetchCredential(entity.credentialId);
 
-        return this._mapEntity(entity, credential);
+        return {
+            id: entity.id.toString(),
+            credential,
+            userId: entity.userId?.toString(),
+            name: entity.name,
+            externalId: entity.externalId,
+            moduleName: entity.moduleName,
+            ...(entity.data || {}),
+        };
     }
 
     /**
@@ -297,7 +292,15 @@ class ModuleRepositoryPostgres 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.toString(),
+            credential: credentialMap.get(e.credentialId) || null,
+            userId: e.userId?.toString(),
+            name: e.name,
+            externalId: e.externalId,
+            moduleName: e.moduleName,
+            ...(e.data || {}),
+        }));
     }
 
     /**
@@ -305,13 +308,9 @@ class ModuleRepositoryPostgres extends ModuleRepositoryInterface {
      * Replaces: Entity.create(entityData)
      *
      * @param {Object} entityData - Entity data (with string IDs from application layer)
-     * @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,
@@ -329,7 +328,6 @@ class ModuleRepositoryPostgres extends ModuleRepositoryInterface {
             name,
             moduleName,
             externalId,
-            organizationId: this._convertId(tenancy.organizationId ?? null),
             data: dynamicData,
         };
 
@@ -339,7 +337,15 @@ class ModuleRepositoryPostgres extends ModuleRepositoryInterface {
 
         const credentialObj = await this._fetchCredential(entity.credentialId);
 
-        return this._mapEntity(entity, credentialObj);
+        return {
+            id: entity.id.toString(),
+            credential: credentialObj,
+            userId: entity.userId?.toString(),
+            name: entity.name,
+            externalId: entity.externalId,
+            moduleName: entity.moduleName,
+            ...(entity.data || {}),
+        };
     }
 
     /**
@@ -395,7 +401,15 @@ class ModuleRepositoryPostgres extends ModuleRepositoryInterface {
 
             const credentialObj = await this._fetchCredential(entity.credentialId);
 
-            return this._mapEntity(entity, credentialObj);
+            return {
+                id: entity.id.toString(),
+                credential: credentialObj,
+                userId: entity.userId?.toString(),
+                name: entity.name,
+                externalId: entity.externalId,
+                moduleName: entity.moduleName,
+                ...(entity.data || {}),
+            };
         } catch (error) {
             if (error.code === 'P2025') {
                 return null;
@@ -460,11 +474,6 @@ class ModuleRepositoryPostgres 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) {
-            where.organizationId = this._convertId(filter.organizationId);
-        }
-
         return where;
     }
 }

package/modules/use-cases/entity-operations-for-user.js

@@ -1,11 +1,4 @@
 const Boom = require('@hapi/boom');
-const {
-    describeRecord,
-    visibilityClauses,
-    matchesListFilters,
-} = require('../scope-visibility');
-const { DEFAULT_SCOPE_POLICY } = require('../scope-policy');
-const { assertCanManage } = require('./manage-access');
 
 /**
  * Management API v2 entity operations. Each one starts from
@@ -13,55 +6,29 @@ const { assertCanManage } = require('./manage-access');
  * (missing or foreign entity = 404).
  */
 
-/**
- * The entities the caller may see in the active organization (ADR-056 §3.4,
- * §3.6): the organization's own, and the caller's individual ones by the
- * visibility rule. Each carries `tenancy` ({scope, owner, organizationId,
- * access}); the stored entity is otherwise untouched.
- */
+/** The caller's connected entities. */
 class ListEntitiesForUser {
-    constructor({ moduleRepository, scopePolicy }) {
+    constructor({ moduleRepository }) {
         this.moduleRepository = moduleRepository;
-        this.scopePolicy = scopePolicy || DEFAULT_SCOPE_POLICY;
     }
 
-    /**
-     * @param {Object} user - authenticated User
-     * @param {{scope?: string, owner?: string}} [filters] - `?scope=` and `?owner=`
-     */
-    async execute(user, filters = {}) {
-        const ctx = this.scopePolicy.accessContext(user);
-        const entities = await this.moduleRepository.findEntitiesByOwnership(
-            visibilityClauses(ctx, 'entity')
+    /** @param {Object} user - authenticated User */
+    async execute(user) {
+        const entities = await this.moduleRepository.findEntitiesByUserId(
+            user.getId()
         );
-        const listed = [];
-        for (const entity of Array.isArray(entities) ? entities : []) {
-            // The query is the filter; this is the same rule applied again,
-            // so a repository that returns too much cannot widen the list.
-            const tenancy = describeRecord(entity, ctx, 'entity');
-            if (tenancy && matchesListFilters(tenancy, filters)) {
-                listed.push({ ...entity, tenancy });
-            }
-        }
-        return listed;
+        return Array.isArray(entities) ? entities : [];
     }
 }
 
-/** One entity the caller may use, with its `tenancy`. */
+/** One entity the caller owns. */
 class GetEntityForUser {
     constructor({ getEntityModuleForUser }) {
         this.getEntityModuleForUser = getEntityModuleForUser;
     }
 
     async execute(entityId, user) {
-        const entity = await this.getEntityModuleForUser.loadOwnedEntity(
-            entityId,
-            user
-        );
-        return {
-            ...entity,
-            tenancy: this.getEntityModuleForUser.describe(entity, user),
-        };
+        return this.getEntityModuleForUser.loadOwnedEntity(entityId, user);
     }
 }
 
@@ -112,10 +79,10 @@ class RefreshEntityOptionsForUser {
 }
 
 /**
- * Deletes an entity the caller may manage (the owner; for an organization
- * entity, an organization admin). Refuses with 409 while integrations still
- * use it, so an integration never points at a missing entity. The credential
- * is left alone (others may share it); delete it through /api/v2/credentials.
+ * Deletes an entity the caller owns. Refuses with 409 while integrations
+ * still use it, so an integration never points at a missing entity. The
+ * credential is left alone (others may share it); delete it through
+ * /api/v2/credentials.
  */
 class DeleteEntityForUser {
     constructor({ getEntityModuleForUser, moduleRepository, integrationRepository }) {
@@ -129,10 +96,6 @@ class DeleteEntityForUser {
             entityId,
             user
         );
-        assertCanManage(
-            this.getEntityModuleForUser.describe(entity, user)?.access,
-            `entity ${entity.id}`
-        );
         const integrations =
             (await this.integrationRepository.findIntegrationsByEntityId(
                 entity.id

package/modules/use-cases/entity-types.js

@@ -59,31 +59,10 @@ function findDefinition(moduleDefinitions, entityType) {
     return definition;
 }
 
-/**
- * With a scope policy the entry also says which scope a new connection gets
- * and which a request may choose (ADR-056 §3.1), so a UI can offer the choice.
- * `global` is never offered: a tenant request cannot create one.
- */
-const scopeOf = (scopePolicy, name, user) => {
-    if (!scopePolicy) return {};
-    const { scope, source, allow } = scopePolicy.resolveScope({
-        entityType: name,
-        user,
-    });
-    return {
-        scope: {
-            default: scope,
-            allow: allow.filter((value) => value !== 'global'),
-            source,
-        },
-    };
-};
-
-const describeEntry = (name, entry, scopePolicy, user) => ({
+const describeEntry = (name, entry) => ({
     // The registry key is the name the API uses, whatever the definition spells.
     ...describeEntityType(entry.definition, name),
     usedBy: usedByOf(entry),
-    ...scopeOf(scopePolicy, name, user),
 });
 
 function requireRegistry(entityTypeRegistry) {
@@ -99,34 +78,31 @@ function requireRegistry(entityTypeRegistry) {
  * bind each type; it is empty for a registry-only type.
  */
 class ListEntityTypes {
-    constructor({ entityTypeRegistry, scopePolicy }) {
+    constructor({ entityTypeRegistry }) {
         this.registry = requireRegistry(entityTypeRegistry);
-        this.scopePolicy = scopePolicy;
     }
 
-    /** @param {{user?: Object}} [params] - the caller, for the level-6 scope default */
-    async execute({ user } = {}) {
+    async execute() {
         return [...this.registry]
-            .map(([name, entry]) => describeEntry(name, entry, this.scopePolicy, user))
+            .map(([name, entry]) => describeEntry(name, entry))
             .sort((a, b) => a.name.localeCompare(b.name));
     }
 }
 
 /** Describes one entity type, looked up by its registry key; 404 when absent. */
 class GetEntityType {
-    constructor({ entityTypeRegistry, scopePolicy }) {
+    constructor({ entityTypeRegistry }) {
         this.registry = requireRegistry(entityTypeRegistry);
-        this.scopePolicy = scopePolicy;
     }
 
-    async execute(entityType, { user } = {}) {
+    async execute(entityType) {
         const entry = this.registry.get(entityType);
         if (!entry) {
             throw Boom.notFound(`Entity type '${entityType}' not found`, {
                 code: 'ENTITY_TYPE_NOT_FOUND',
             });
         }
-        return describeEntry(entityType, entry, this.scopePolicy, user);
+        return describeEntry(entityType, entry);
     }
 }
 

package/modules/use-cases/execute-entity-proxy-request.js

@@ -98,24 +98,9 @@ class ExecuteEntityProxyRequest {
             audit.requestBytes = validated.requestBytes;
             const path = normalizeProxyPath(validated.path);
 
-            // Access is `use` in the active organization (ADR-056 §3.5, §3.6): the
-            // owner's entity there, or the organization's. A `global` entity is
-            // never the tenant's.
             const { entity, definition, module } =
                 await this.getEntityModuleForUser.execute(entityId, user);
             audit.module = definition.moduleName;
-            // Narrowest by default (§3.5): proxying through a shared credential
-            // lets any member act on the organization's account, so only an
-            // individual entity may be proxied until `managementApi.proxy.scopes`
-            // lets an app opt in to `organization`.
-            // TODO(F6): read proxy.scopes here instead of refusing outright.
-            if (this.getEntityModuleForUser.describe(entity, user)?.scope !== 'individual') {
-                throw new ProxyRequestError(
-                    'PROXY_NOT_ALLOWED',
-                    'The entity proxy only accepts individual entities; organization-level entities are not proxied',
-                    { module: definition.moduleName, reason: 'scope' }
-                );
-            }
             const credentialRef = entity.credential;
             const credentialId =
                 credentialRef && typeof credentialRef === 'object'

package/modules/use-cases/get-entities-for-user.js

@@ -1,11 +1,8 @@
 const { Module } = require('../module');
 const { mapModuleClassToModuleDTO } = require('../utils/map-module-dto');
-const { describeRecord, visibilityClauses } = require('../scope-visibility');
-const { DEFAULT_SCOPE_POLICY } = require('../scope-policy');
 
 class GetEntitiesForUser {
-    constructor({ moduleRepository, moduleDefinitions, scopePolicy }) {
-        this.scopePolicy = scopePolicy || DEFAULT_SCOPE_POLICY;
+    constructor({ moduleRepository, moduleDefinitions }) {
         this.moduleRepository = moduleRepository;
 
         this.definitionMap = new Map();
@@ -14,24 +11,16 @@ class GetEntitiesForUser {
         }
     }
 
-    /**
-     * The entities a `User` may see in the active organization (ADR-056 §3.6).
-     * @param {Object} user - authenticated User
-     */
-    async execute(user) {
-        const ctx = this.scopePolicy.accessContext(user);
-        const found = await this.moduleRepository.findEntitiesByOwnership(
-            visibilityClauses(ctx, 'entity')
-        );
-        const entities = (found || []).filter((entity) =>
-            describeRecord(entity, ctx, 'entity')
+    async execute(userId) {
+        const entities = await this.moduleRepository.findEntitiesByUserId(
+            userId
         );
 
         return entities.map((entity) => {
             const definition = this.definitionMap.get(entity.moduleName);
 
             const moduleInstance = new Module({
-                userId: entity.userId,
+                userId,
                 definition: definition,
                 entity: entity,
             });

package/modules/use-cases/get-entity-module-for-user.js

@@ -1,13 +1,8 @@
 const Boom = require('@hapi/boom');
-const { describeRecord } = require('../scope-visibility');
-const { DEFAULT_SCOPE_POLICY } = require('../scope-policy');
 
 /**
  * True when `user` may act on records owned by `ownerId`. Uses the User
  * domain object's rule (individual or organisation user model) when present.
- * This is the owner-only rule: it ignores the organization a record belongs
- * to, so it no longer decides access to an entity or an integration
- * (modules/scope-visibility.js does). Credentials still use it.
  * @param {Object} user - authenticated User (or a plain { getId } double)
  * @param {string|number} ownerId
  */
@@ -35,11 +30,8 @@ class GetEntityModuleForUser {
      * @param {import('../repositories/module-repository-interface').ModuleRepositoryInterface} params.moduleRepository
      * @param {Array<Object>} params.moduleDefinitions
      * @param {Function} [params.createModule] - builds a Module; injectable for tests.
-     * @param {Object} [params.scopePolicy] - from createScopePolicy; with none the
-     *   app configures nothing (ADR-056 §3.1).
      */
-    constructor({ moduleRepository, moduleDefinitions, createModule, scopePolicy }) {
-        this.scopePolicy = scopePolicy || DEFAULT_SCOPE_POLICY;
+    constructor({ moduleRepository, moduleDefinitions, createModule }) {
         this.moduleRepository = moduleRepository;
         this.moduleDefinitions = moduleDefinitions || [];
         this.createModule = createModule || defaultCreateModule;
@@ -69,11 +61,7 @@ class GetEntityModuleForUser {
         return { entity, definition, module };
     }
 
-    /**
-     * The entity record, or a 404 when it is missing or the caller may not use
-     * it: not theirs, or paired with another organization (ADR-056 §3.6). A
-     * `global` entity is never the tenant's to load.
-     */
+    /** The entity record, or a 404 when it is missing or not the caller's. */
     async loadOwnedEntity(entityId, user) {
         let entity = null;
         try {
@@ -86,21 +74,13 @@ class GetEntityModuleForUser {
                 throw error;
             }
         }
-        if (!entity || !this.describe(entity, user)) {
+        if (!entity || !userOwns(user, entity.userId)) {
             throw Boom.notFound(`Entity ${entityId} not found`, {
                 code: 'ENTITY_NOT_FOUND',
             });
         }
         return entity;
     }
-
-    /**
-     * `{ scope, owner, organizationId, access }` of an entity to this caller,
-     * or null when they may not see it (§3.4).
-     */
-    describe(entity, user) {
-        return describeRecord(entity, this.scopePolicy.accessContext(user), 'entity');
-    }
 }
 
 module.exports = { GetEntityModuleForUser, userOwns };

package/modules/use-cases/get-entity-options-by-id.js

@@ -1,5 +1,4 @@
 const { Module } = require('../module');
-const { DEFAULT_SCOPE_POLICY } = require('../scope-policy');
 
 class GetEntityOptionsById {
     /**
@@ -7,11 +6,9 @@ class GetEntityOptionsById {
      * @param {import('../repositories/module-repository-interface').ModuleRepositoryInterface} params.moduleRepository
      * @param {} params.moduleDefinitions
      */
-    constructor({ moduleRepository, moduleDefinitions, scopePolicy }) {
+    constructor({ moduleRepository, moduleDefinitions }) {
         this.moduleRepository = moduleRepository;
         this.moduleDefinitions = moduleDefinitions;
-        // Who may load an entity follows its scope (ADR-056 §3.6).
-        this.scopePolicy = scopePolicy || DEFAULT_SCOPE_POLICY;
     }
 
     /**
@@ -38,7 +35,7 @@ class GetEntityOptionsById {
 
         // Validate entity ownership
         const isOwned = typeof userIdOrUser === 'object' && userIdOrUser?.ownsUserId
-            ? this.scopePolicy.canUseEntity(userIdOrUser, entity)
+            ? userIdOrUser.ownsUserId(entity.userId)
             : entity.userId?.toString() === userId?.toString();
 
         if (!isOwned) {
@@ -60,11 +57,8 @@ class GetEntityOptionsById {
             );
         }
 
-        // Built for the entity's OWNER, not the caller: a caller may use an
-        // organization's entity, and a token refresh during this call must
-        // update the owner's credential, not create one under the caller.
         const module = new Module({
-            userId: entity.userId ?? userId,
+            userId,
             entity,
             definition: moduleDefinition,
         });

package/modules/use-cases/get-module.js

@@ -1,12 +1,9 @@
 const { Module } = require('../module');
-const { DEFAULT_SCOPE_POLICY } = require('../scope-policy');
 
 class GetModule {
-    constructor({ moduleRepository, moduleDefinitions, scopePolicy }) {
+    constructor({ moduleRepository, moduleDefinitions }) {
         this.moduleRepository = moduleRepository;
         this.moduleDefinitions = moduleDefinitions;
-        // Who may load an entity follows its scope (ADR-056 §3.6).
-        this.scopePolicy = scopePolicy || DEFAULT_SCOPE_POLICY;
     }
 
     /**
@@ -35,7 +32,7 @@ class GetModule {
         // If User object provided, use ownsUserId to check linked users
         // Otherwise fall back to simple equality check
         const isOwned = typeof userIdOrUser === 'object' && userIdOrUser?.ownsUserId
-            ? this.scopePolicy.canUseEntity(userIdOrUser, entity)
+            ? userIdOrUser.ownsUserId(entity.userId)
             : entity.userId?.toString() === userId?.toString();
 
         if (!isOwned) {
@@ -56,11 +53,8 @@ class GetModule {
             );
         }
 
-        // Built for the entity's OWNER, not the caller: a caller may use an
-        // organization's entity, and a token refresh during this call must
-        // update the owner's credential, not create one under the caller.
         const module = new Module({
-            userId: entity.userId ?? userId,
+            userId,
             entity,
             definition: moduleDefinition,
         });