@friggframework/core 2.0.0--canary.690.08cd07e.0 → 2.0.0--canary.693.d8859c2.0

package/credential/use-cases/credential-operations-for-user.js

@@ -1,202 +0,0 @@
-const Boom = require('@hapi/boom');
-const {
-    createScopePolicy,
-    describeRecord,
-    visibilityClauses,
-    matchesListFilters,
-    SCOPES,
-} = require('../../modules/entity-scope');
-const { assertCanManage } = require('../../modules/use-cases/manage-access');
-
-/**
- * Management API v2 credential operations (ADR-056 §3.4, §3.6). A credential
- * has no module name and no organization of its own:
- *
- * - its `type` and `entityIds` come from the entities that use it that the
- *   caller may see, so the same person's account connected in two
- *   organizations (one credential, two entities) lists in each organization
- *   with that organization's entity only;
- * - who it belongs to is its OWNER (`credential.userId`), never the entities:
- *   a credential an individual entity and an organization entity both point at
- *   (possible only through legacy data) is described by whoever owns the
- *   credential, so the answer cannot change with the order the entities load;
- * - a credential whose entities are all out of sight (another organization's)
- *   is a 404, and one with no entities at all (its entity was deleted) is
- *   visible to its owner only, as it was before scoping.
- */
-
-const credentialIdOf = (entity) => {
-    const ref = entity.credential ?? entity.credentialId;
-    if (ref === undefined || ref === null) return null;
-    if (typeof ref === 'object') {
-        const id = ref.id ?? ref._id;
-        return id === undefined || id === null ? null : String(id);
-    }
-    return String(ref);
-};
-
-/** Adds `type` and `entityIds` from the user's entities to each credential. */
-function withEntityUsage(credentials, entities) {
-    const usage = new Map();
-    for (const entity of entities || []) {
-        const credentialId = credentialIdOf(entity);
-        if (!credentialId) continue;
-        const entry = usage.get(credentialId) || { type: null, entityIds: [] };
-        entry.type = entry.type || entity.moduleName || null;
-        entry.entityIds.push(String(entity.id));
-        usage.set(credentialId, entry);
-    }
-    return credentials.map((credential) => {
-        const entry = usage.get(String(credential.id)) || {
-            type: null,
-            entityIds: [],
-        };
-        return { ...credential, type: entry.type, entityIds: entry.entityIds };
-    });
-}
-
-/**
- * `{scope, owner, organizationId, access}` of a credential for this caller, or
- * null when its owner is neither the caller nor the active organization. Built
- * by `describeRecord` over the row a connection by this owner has: the
- * organization of a visible entity, else the one a new entity would get.
- */
-function credentialTenancy(credential, visibleEntities, ctx) {
-    const entityOrg = visibleEntities.find(
-        (entity) => entity.organizationId !== undefined && entity.organizationId !== null
-    )?.organizationId;
-    const organizationId =
-        entityOrg ?? (ctx.individualAcross === 'all' ? null : ctx.activeOrgId);
-    return describeRecord({ userId: credential.userId, organizationId }, ctx, 'entity');
-}
-
-/** The entities of `entities` the caller may see, each with its `tenancy`. */
-function visibleOf(entities, ctx) {
-    const visible = [];
-    for (const entity of entities || []) {
-        const tenancy = describeRecord(entity, ctx, 'entity');
-        if (tenancy) visible.push({ ...entity, tenancy });
-    }
-    return visible;
-}
-
-/**
- * The caller's credentials with their type, the entities of them they may see
- * and `tenancy`. Credentials with no entity at all are listed too, for the
- * person and the active organization that own them.
- */
-class ListCredentialsForUser {
-    constructor({ credentialRepository, moduleRepository, scopePolicy }) {
-        this.credentialRepository = credentialRepository;
-        this.moduleRepository = moduleRepository;
-        this.scopePolicy = scopePolicy || createScopePolicy();
-    }
-
-    /** @param {{scope?: string, owner?: string}} [filters] */
-    async execute(user, filters = {}) {
-        const ctx = this.scopePolicy.accessContext(user);
-        const owners = [...new Set([ctx.callerId, ctx.activeOrgId].filter(Boolean))];
-        const [found, perOwner, owned] = await Promise.all([
-            this.moduleRepository.findEntitiesByOwnership(visibilityClauses(ctx, 'entity')),
-            Promise.all(owners.map((id) => this.credentialRepository.findCredentialsByUserId(id))),
-            // Every entity of those owners, in any organization: only to tell a credential
-            // with no entity at all from one used elsewhere.
-            Promise.all(owners.map((id) => this.moduleRepository.findEntitiesByUserId(id))),
-        ]);
-        const visible = visibleOf(found, ctx);
-        const usedAnywhere = new Set(owned.flat().map(credentialIdOf).filter(Boolean));
-        const listed = [];
-        for (const credential of perOwner.flat().filter(Boolean)) {
-            const id = String(credential.id);
-            const referencing = visible.filter((entity) => credentialIdOf(entity) === id);
-            if (referencing.length === 0 && usedAnywhere.has(id)) continue;
-            const tenancy = credentialTenancy(credential, referencing, ctx);
-            if (!tenancy || !matchesListFilters(tenancy, filters)) continue;
-            listed.push({ ...withEntityUsage([credential], referencing)[0], tenancy });
-        }
-        return listed;
-    }
-}
-
-/** One credential the caller may see: see the header. 404 otherwise. */
-class GetCredentialForUserV2 {
-    constructor({ credentialRepository, moduleRepository, scopePolicy }) {
-        this.credentialRepository = credentialRepository;
-        this.moduleRepository = moduleRepository;
-        this.scopePolicy = scopePolicy || createScopePolicy();
-    }
-
-    async execute(credentialId, user) {
-        const notFound = () =>
-            Boom.notFound(`Credential ${credentialId} not found`, {
-                code: 'CREDENTIAL_NOT_FOUND',
-            });
-        let credential = null;
-        try {
-            credential = await this.credentialRepository.findCredentialById(
-                credentialId
-            );
-        } catch (error) {
-            if (!/Invalid ID|ObjectId|Malformed/i.test(error?.message || '')) {
-                throw error;
-            }
-        }
-        if (!credential) throw notFound();
-        const ctx = this.scopePolicy.accessContext(user);
-
-        const referencing =
-            (await this.moduleRepository.findEntities({ credentialId: credential.id })) || [];
-        const visible = visibleOf(referencing, ctx);
-        if (referencing.length > 0 && visible.length === 0) throw notFound();
-        const tenancy = credentialTenancy(credential, visible, ctx);
-        if (!tenancy) throw notFound();
-        return { ...withEntityUsage([credential], visible)[0], tenancy };
-    }
-}
-
-/**
- * Deletes a credential the caller may manage. The entities that used it stay,
- * with their credential unset, so they show as needing re-authorization rather
- * than disappearing from integrations.
- *
- * Refuses with 409 `CREDENTIAL_SHARED` while an entity the caller cannot see
- * still uses it: one credential row serves the same provider account in every
- * organization, and deleting it from one would break the other. The message
- * says nothing about the other connections (not even how many): remove the
- * entities that use it, and it goes with the last one.
- */
-class DeleteCredentialForUser {
-    constructor({ credentialRepository, moduleRepository, getCredentialForUser }) {
-        this.credentialRepository = credentialRepository;
-        this.moduleRepository = moduleRepository;
-        this.getCredentialForUser = getCredentialForUser;
-    }
-
-    async execute(credentialId, user) {
-        const credential = await this.getCredentialForUser.execute(
-            credentialId,
-            user
-        );
-        assertCanManage(credential.tenancy.access, `credential ${credential.id}`);
-        const usedBy =
-            (await this.moduleRepository.findEntities({ credentialId: credential.id })) || [];
-        if (usedBy.length > credential.entityIds.length) {
-            throw Boom.conflict(
-                `Credential ${credential.id} is still in use by other connections and cannot be deleted from here`,
-                { code: 'CREDENTIAL_SHARED' }
-            );
-        }
-        for (const entityId of credential.entityIds) {
-            await this.moduleRepository.unsetCredential(entityId);
-        }
-        await this.credentialRepository.deleteCredentialById(credential.id);
-        return { id: String(credential.id), entityIds: credential.entityIds };
-    }
-}
-
-module.exports = {
-    ListCredentialsForUser,
-    GetCredentialForUserV2,
-    DeleteCredentialForUser,
-    withEntityUsage,
-};

package/credential/use-cases/reauthorize-credential-for-user.js

@@ -1,73 +0,0 @@
-const Boom = require('@hapi/boom');
-const { assertCanManage } = require('../../modules/use-cases/manage-access');
-
-/**
- * Re-authorization of a credential the caller owns (Management API v2). It
- * runs the same flow as /api/v2/authorize for the credential's entity type,
- * with the session bound to the credential so it cannot be reused for
- * anything else.
- */
-async function credentialEntityType(getCredentialForUser, credentialId, user) {
-    const credential = await getCredentialForUser.execute(credentialId, user);
-    if (!credential.type) {
-        throw Boom.conflict(
-            `Credential ${credentialId} is not used by any entity, so its type is unknown; authorize a new connection instead`,
-            { code: 'CREDENTIAL_TYPE_UNKNOWN' }
-        );
-    }
-    return {
-        entityType: credential.type,
-        credentialId: String(credential.id),
-        // A re-authorization keeps the scope the connection already has.
-        fixedScope: credential.tenancy?.scope,
-        access: credential.tenancy?.access,
-    };
-}
-
-/** GET /api/v2/credentials/:credentialId/reauthorize */
-class GetCredentialReauthorization {
-    constructor({ getCredentialForUser, getAuthorizationStep }) {
-        this.getCredentialForUser = getCredentialForUser;
-        this.getAuthorizationStep = getAuthorizationStep;
-    }
-
-    async execute(credentialId, user, { step = 1, sessionId, state } = {}) {
-        const { entityType, credentialId: boundCredentialId } =
-            await credentialEntityType(this.getCredentialForUser, credentialId, user);
-        return this.getAuthorizationStep.execute({
-            user,
-            entityType,
-            credentialId: boundCredentialId,
-            step,
-            sessionId,
-            state,
-        });
-    }
-}
-
-/** POST /api/v2/credentials/:credentialId/reauthorize */
-class ReauthorizeCredentialForUser {
-    constructor({ getCredentialForUser, submitAuthorizationStep }) {
-        this.getCredentialForUser = getCredentialForUser;
-        this.submitAuthorizationStep = submitAuthorizationStep;
-    }
-
-    async execute(credentialId, user, { data, step = 1, sessionId } = {}) {
-        const { access, ...binding } = await credentialEntityType(
-            this.getCredentialForUser,
-            credentialId,
-            user
-        );
-        // A credential an organization owns: the organization's admins only.
-        assertCanManage(access, `credential ${credentialId}`);
-        return this.submitAuthorizationStep.execute({
-            user,
-            ...binding,
-            data,
-            step,
-            sessionId,
-        });
-    }
-}
-
-module.exports = { GetCredentialReauthorization, ReauthorizeCredentialForUser };

package/database/organization-where.js

@@ -1,18 +0,0 @@
-/**
- * The Prisma `where` fragment for an `organizationId` on MongoDB (ADR-056
- * §3.6), shared by the entity and integration adapters.
- *
- * Prisma on MongoDB: `null` matches only an explicit null and `isSet: false`
- * only a missing field. A row written before the column existed is the common
- * "no organization" case, so `null` here means both.
- */
-function organizationWhere(organizationId) {
-    if (organizationId === null) {
-        return {
-            OR: [{ organizationId: null }, { organizationId: { isSet: false } }],
-        };
-    }
-    return { organizationId };
-}
-
-module.exports = { organizationWhere };

package/database/unique-violation.js

@@ -1,25 +0,0 @@
-/** Mongo/DocumentDB duplicate-key error code. */
-const DUPLICATE_KEY_CODE = 11000;
-/** Prisma's unique-constraint error code (PostgreSQL and MongoDB). */
-const PRISMA_UNIQUE_CODE = 'P2002';
-
-/**
- * Whether `error` is a unique-constraint violation, however the database
- * layer raised it: a Prisma `P2002`, or a duplicate-key `11000`
- * (`documentdb-utils` `insertOne` sets `code` on the error it throws).
- * Matches on the code only, never on message text.
- *
- * @param {unknown} error
- * @returns {boolean}
- */
-function isUniqueViolation(error) {
-    return (
-        error?.code === PRISMA_UNIQUE_CODE || error?.code === DUPLICATE_KEY_CODE
-    );
-}
-
-module.exports = {
-    isUniqueViolation,
-    DUPLICATE_KEY_CODE,
-    PRISMA_UNIQUE_CODE,
-};

package/extensions/bootstrap-runner.js

@@ -1,43 +0,0 @@
-/**
- * Bootstrap Runner
- *
- * Runs extension bootstrap functions in sequence.
- * Bootstrap hooks execute AFTER database connection but BEFORE integration
- * router creation. This is the right place for extensions to:
- *
- * - Load credentials from database into integration definitions
- * - Register additional middleware or services
- * - Perform one-time initialization
- *
- * @example
- * await runExtensionBootstraps(extensions, { prisma, appDefinition });
- */
-
-/**
- * Runs all extension bootstrap functions in sequence.
- *
- * @param {Array<Object>} extensions - Normalized extensions (from extension-loader)
- * @param {Object} context
- * @param {Object} context.prisma - Prisma client instance
- * @param {Object} context.appDefinition - Full app definition
- * @throws {Error} If any bootstrap function fails (fails fast)
- */
-async function runExtensionBootstraps(extensions, context = {}) {
-    if (!extensions || extensions.length === 0) return;
-
-    const { prisma, appDefinition } = context;
-
-    for (const ext of extensions) {
-        if (!ext.bootstrap) continue;
-
-        try {
-            await ext.bootstrap(prisma, appDefinition);
-        } catch (error) {
-            throw new Error(
-                `Extension "${ext.name}" bootstrap failed: ${error.message}`
-            );
-        }
-    }
-}
-
-module.exports = { runExtensionBootstraps };

package/extensions/extension-loader.js

@@ -1,187 +0,0 @@
-/**
- * Extension Loader
- *
- * Validates and normalizes the core extensions of the app definition
- * (`appDefinition.coreExtensions`, an array). Core extensions add custom
- * Prisma models, encryption schemas, admin routes and bootstrap logic to a
- * Frigg app. The key is `coreExtensions`, not `extensions`: ADR-017 keeps
- * `appDefinition.extensions` for its keyed object form.
- *
- * @example
- * const extensions = loadExtensions(appDefinition);
- * // extensions is a normalized array, safe to iterate
- */
-
-const path = require('path');
-const {
-    coreExtensionRoutePathError,
-} = require('../management-api/route-registry');
-
-/**
- * Validates a single extension definition.
- * @param {Object} ext - Raw extension config from app definition
- * @param {number} index - Position in the coreExtensions array (for error messages)
- * @returns {{valid: boolean, errors: string[]}}
- */
-function validateExtension(ext, index) {
-    const prefix = `coreExtensions[${index}]`;
-    const errors = [];
-
-    if (!ext || typeof ext !== 'object') {
-        errors.push(`${prefix}: must be an object`);
-        return { valid: false, errors };
-    }
-
-    if (!ext.name || typeof ext.name !== 'string') {
-        errors.push(`${prefix}.name: required string`);
-    }
-
-    // schema is optional — path to a .prisma file
-    if (ext.schema !== undefined) {
-        if (typeof ext.schema !== 'string') {
-            errors.push(`${prefix}.schema: must be a string (path to .prisma file)`);
-        } else if (!ext.schema.endsWith('.prisma')) {
-            errors.push(`${prefix}.schema: must end with .prisma`);
-        }
-    }
-
-    // encryption is optional — object with model names → { fields: [...] }
-    if (ext.encryption !== undefined) {
-        if (!ext.encryption || typeof ext.encryption !== 'object') {
-            errors.push(`${prefix}.encryption: must be an object`);
-        } else {
-            for (const [model, config] of Object.entries(ext.encryption)) {
-                if (!config || !Array.isArray(config.fields)) {
-                    errors.push(
-                        `${prefix}.encryption.${model}: must have a "fields" array`
-                    );
-                }
-            }
-        }
-    }
-
-    // routes is optional — { path, handler }
-    if (ext.routes !== undefined) {
-        if (!ext.routes || typeof ext.routes !== 'object') {
-            errors.push(`${prefix}.routes: must be an object with { path, handler }`);
-        } else {
-            if (!ext.routes.path || typeof ext.routes.path !== 'string') {
-                errors.push(`${prefix}.routes.path: required string`);
-            } else {
-                const pathError = coreExtensionRoutePathError(ext.routes.path);
-                if (pathError) {
-                    errors.push(`${prefix}.routes.path: ${pathError}`);
-                }
-            }
-            if (!ext.routes.handler) {
-                errors.push(`${prefix}.routes.handler: required (function or module path)`);
-            }
-        }
-    }
-
-    // bootstrap is optional — function or module path
-    if (ext.bootstrap !== undefined) {
-        if (typeof ext.bootstrap !== 'function' && typeof ext.bootstrap !== 'string') {
-            errors.push(
-                `${prefix}.bootstrap: must be a function or a string (module path)`
-            );
-        }
-    }
-
-    return { valid: errors.length === 0, errors };
-}
-
-/**
- * Loads and validates extensions from the app definition.
- *
- * @param {Object} appDefinition - The full app definition
- * @returns {Array<Object>} Normalized extensions array (empty if none)
- * @throws {Error} If any extension fails validation
- */
-function loadExtensions(appDefinition) {
-    if (!appDefinition) return [];
-
-    // The array this loader reads used to be `appDefinition.extensions`;
-    // that key now belongs to ADR-017's keyed object. An array there is the
-    // old spelling: stop at load rather than silently dropping the extensions.
-    if (Array.isArray(appDefinition.extensions)) {
-        throw new Error(
-            'appDefinition.extensions (array) was renamed to appDefinition.coreExtensions; ' +
-                'move the array to coreExtensions'
-        );
-    }
-
-    const raw = appDefinition.coreExtensions;
-    if (!raw) return [];
-
-    if (!Array.isArray(raw)) {
-        throw new Error('appDefinition.coreExtensions must be an array');
-    }
-
-    if (raw.length === 0) return [];
-
-    const allErrors = [];
-
-    const normalized = raw.map((ext, index) => {
-        const { valid, errors } = validateExtension(ext, index);
-        if (!valid) {
-            allErrors.push(...errors);
-            return null;
-        }
-
-        // Normalize bootstrap — resolve string paths to functions
-        let bootstrapFn = null;
-        if (typeof ext.bootstrap === 'function') {
-            bootstrapFn = ext.bootstrap;
-        } else if (typeof ext.bootstrap === 'string') {
-            bootstrapFn = require(ext.bootstrap);
-        }
-
-        // Normalize route handler — resolve string paths to functions
-        let routeHandler = null;
-        if (ext.routes) {
-            if (typeof ext.routes.handler === 'function') {
-                routeHandler = ext.routes.handler;
-            } else if (typeof ext.routes.handler === 'string') {
-                routeHandler = require(ext.routes.handler);
-            } else {
-                routeHandler = ext.routes.handler;
-            }
-        }
-
-        return {
-            name: ext.name,
-            schema: ext.schema || null,
-            encryption: ext.encryption || null,
-            routes: ext.routes
-                ? { path: ext.routes.path, handler: routeHandler }
-                : null,
-            bootstrap: bootstrapFn,
-        };
-    });
-
-    if (allErrors.length > 0) {
-        throw new Error(
-            `Invalid extension configuration:\n- ${allErrors.join('\n- ')}`
-        );
-    }
-
-    return normalized.filter(Boolean);
-}
-
-/**
- * Get extension schema file paths from loaded extensions.
- * @param {Array<Object>} extensions - Normalized extensions
- * @returns {string[]} Array of absolute paths to .prisma schema files
- */
-function getExtensionSchemaPaths(extensions) {
-    return extensions
-        .filter((ext) => ext.schema)
-        .map((ext) => ext.schema);
-}
-
-module.exports = {
-    loadExtensions,
-    validateExtension,
-    getExtensionSchemaPaths,
-};

package/extensions/index.js

@@ -1,41 +0,0 @@
-/**
- * Frigg Extension System
- *
- * Extensions allow integration developers to extend Frigg Core with:
- * - Custom Prisma models (schema composition)
- * - Encrypted fields (encryption registry merge)
- * - Admin API routes (route mounting)
- * - Bootstrap lifecycle hooks (credential loading, etc.)
- *
- * @module @friggframework/core/extensions
- */
-
-const { loadExtensions, validateExtension, getExtensionSchemaPaths } = require('./extension-loader');
-const { composeSchemas, extractModelBlocks, getSchemaFilePaths } = require('./schema-composer');
-const {
-    mountExtensionRoutes,
-    createExtensionRoutesRouter,
-} = require('./route-mounter');
-const { runExtensionBootstraps } = require('./bootstrap-runner');
-const { initializeApp, resetInitialization } = require('./initialize-app');
-
-module.exports = {
-    // Extension loading & validation
-    loadExtensions,
-    validateExtension,
-    getExtensionSchemaPaths,
-
-    // Schema composition
-    composeSchemas,
-    extractModelBlocks,
-    getSchemaFilePaths,
-
-    // Route mounting
-    mountExtensionRoutes,
-    createExtensionRoutesRouter,
-
-    // Bootstrap lifecycle
-    runExtensionBootstraps,
-    initializeApp,
-    resetInitialization,
-};