@indexnetwork/protocol 22.0.0-rc.499.1 → 64.0.0-rc.604.2

package/dist/opportunities/opportunity.persist.js

@@ -1,145 +0,0 @@
-/**
- * Shared persist phase for opportunity creation: enrichOrCreate → create (or create+expire) → optional chat injection.
- * Used by the opportunity graph persist node and by the manual opportunity service for consistency.
- */
-import { enrichOrCreate } from "./opportunity.enricher.js";
-import { normalizeCreateOpportunityActorIntents } from './opportunity.actor.js';
-import { protocolLogger } from '../shared/observability/protocol.logger.js';
-const logger = protocolLogger('OpportunityPersist');
-/** Bind owned-intent discovery actors to the already-authorized trigger intent. */
-function bindOwnedIntentActors(data, ownerUserId, triggerIntentId) {
-    const actors = [];
-    const boundActorIndexes = new Map();
-    for (const actor of data.actors) {
-        if (actor.userId !== ownerUserId || actor.role === 'introducer') {
-            actors.push(actor);
-            continue;
-        }
-        const boundActor = {
-            ...actor,
-            intent: triggerIntentId,
-        };
-        const key = JSON.stringify([boundActor.networkId, boundActor.userId, triggerIntentId]);
-        const existingIndex = boundActorIndexes.get(key);
-        if (existingIndex === undefined) {
-            boundActorIndexes.set(key, actors.length);
-            actors.push(boundActor);
-        }
-        else {
-            actors[existingIndex] = boundActor;
-        }
-    }
-    return { ...data, actors };
-}
-/**
- * Persist one or more opportunities: enrich (merge overlapping), create, expire replaced, optional chat injection.
- * When the database has createOpportunityAndExpireIds and enrichment produced expireIds, uses it for atomic create+expire.
- * Returns both created and expired so callers can emit events (e.g. manual service).
- */
-export async function persistOpportunities(params) {
-    const { database, embedder, items, injectChat, networkEligibility, intentDedupScope } = params;
-    const created = [];
-    const expired = [];
-    const conflicts = [];
-    const errors = [];
-    for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
-        const data = items[itemIndex];
-        try {
-            const normalizedData = normalizeCreateOpportunityActorIntents(data);
-            if (intentDedupScope
-                && intentDedupScope.triggerIntentId !== networkEligibility?.triggerIntentId) {
-                throw new Error('Intent-scoped dedup trigger must match network eligibility');
-            }
-            const scopedData = intentDedupScope && networkEligibility
-                ? bindOwnedIntentActors(normalizedData, networkEligibility.ownerUserId, intentDedupScope.triggerIntentId)
-                : normalizedData;
-            const enrichment = await enrichOrCreate(database, embedder, scopedData, intentDedupScope && networkEligibility
-                ? {
-                    ownedIntentScope: {
-                        triggerIntentId: intentDedupScope.triggerIntentId,
-                        ownerUserId: networkEligibility.ownerUserId,
-                    },
-                }
-                : undefined);
-            const normalizedToCreate = normalizeCreateOpportunityActorIntents(enrichment.data);
-            const toCreate = intentDedupScope && networkEligibility
-                ? bindOwnedIntentActors(normalizedToCreate, networkEligibility.ownerUserId, intentDedupScope.triggerIntentId)
-                : normalizedToCreate;
-            if (enrichment.enriched) {
-                toCreate.status = enrichment.resolvedStatus;
-            }
-            if (intentDedupScope) {
-                if (!networkEligibility?.triggerIntentId) {
-                    throw new Error('Intent-scoped dedup requires trigger-intent network eligibility');
-                }
-                if (!database.persistIntentScopedOpportunityIfNetworkEligible) {
-                    throw new Error('Intent-scoped atomic persistence is required for owned-intent discovery');
-                }
-                const result = await database.persistIntentScopedOpportunityIfNetworkEligible(toCreate, enrichment.enriched ? enrichment.expiredIds : [], { ...networkEligibility, triggerIntentId: networkEligibility.triggerIntentId }, intentDedupScope.dedupWindowMs);
-                if (!result)
-                    continue;
-                if ('conflict' in result) {
-                    conflicts.push({ itemIndex, finalAtomic: true, ...result.conflict });
-                    continue;
-                }
-                created.push(result.created);
-                expired.push(...result.expired);
-            }
-            else if (networkEligibility) {
-                if (enrichment.enriched && enrichment.expiredIds.length > 0) {
-                    if (!database.createOpportunityAndExpireIdsIfNetworkEligible) {
-                        throw new Error('Network-eligible create+expire is required for discovery persistence');
-                    }
-                    const result = await database.createOpportunityAndExpireIdsIfNetworkEligible(toCreate, enrichment.expiredIds, networkEligibility);
-                    if (!result)
-                        continue;
-                    created.push(result.created);
-                    expired.push(...result.expired);
-                }
-                else {
-                    if (!database.createOpportunityIfNetworkEligible) {
-                        throw new Error('Network-eligible create is required for discovery persistence');
-                    }
-                    const c = await database.createOpportunityIfNetworkEligible(toCreate, networkEligibility);
-                    if (!c)
-                        continue;
-                    created.push(c);
-                }
-            }
-            else if (database.createOpportunityAndExpireIds &&
-                enrichment.enriched &&
-                enrichment.expiredIds.length > 0) {
-                const result = await database.createOpportunityAndExpireIds(toCreate, enrichment.expiredIds);
-                created.push(result.created);
-                expired.push(...result.expired);
-            }
-            else {
-                const c = await database.createOpportunity(toCreate);
-                created.push(c);
-                if (enrichment.enriched && enrichment.expiredIds.length > 0) {
-                    for (const id of enrichment.expiredIds) {
-                        await database.updateOpportunityStatus(id, 'expired');
-                    }
-                    if (database.getOpportunity) {
-                        for (const id of enrichment.expiredIds) {
-                            const opp = await database.getOpportunity(id);
-                            if (opp)
-                                expired.push(opp);
-                        }
-                    }
-                }
-            }
-            const lastCreated = created[created.length - 1];
-            if (lastCreated?.status === 'pending' && injectChat) {
-                await injectChat(lastCreated).catch((err) => {
-                    logger.warn('Chat injection failed', { opportunityId: lastCreated.id, error: err });
-                });
-            }
-        }
-        catch (err) {
-            errors.push({ itemIndex, error: err });
-            logger.warn('Item failed', { itemIndex, error: err });
-        }
-    }
-    return { created, expired, conflicts, ...(errors.length > 0 ? { errors } : {}) };
-}

package/dist/opportunities/opportunity.persistence-admission.d.ts

@@ -1,39 +0,0 @@
-import type { Id, Opportunity, OpportunityActor, OpportunityGraphDatabase, OpportunityNetworkEligibility } from '../shared/interfaces/database.interface.js';
-/** Narrow final-boundary port for opportunity persistence admission and guarded reactivation. */
-export type OpportunityPersistenceAdmissionPort = Pick<OpportunityGraphDatabase, 'getActiveNetworkMembershipPairs' | 'getNetworkIdsForIntent' | 'getNetworkMemberships' | 'updateOpportunityStatusIfNetworkEligible'>;
-type EvaluatedPersistenceCandidate = {
-    actors: Array<{
-        userId: Id<'users'>;
-        networkId?: Id<'networks'> | null;
-    }>;
-};
-export interface OpportunityPersistenceAdmissionInput<T extends EvaluatedPersistenceCandidate> {
-    ownerUserId: Id<'users'>;
-    triggerIntentId?: Id<'intents'>;
-    networkId?: Id<'networks'>;
-    indexScope?: readonly Id<'networks'>[];
-    evaluatedOpportunities: readonly T[];
-}
-export type OpportunityPersistenceAdmission<T extends EvaluatedPersistenceCandidate> = {
-    kind: 'empty_scope';
-} | {
-    kind: 'admitted';
-    allowedNetworkIds: Id<'networks'>[];
-    networkEligibility: OpportunityNetworkEligibility;
-    evaluatedOpportunities: T[];
-};
-/**
- * Recomputes the owner-side scope at the final write boundary and removes
- * evaluator outputs whose actor/network anchors are no longer active.
- */
-export declare function admitOpportunityPersistence<T extends EvaluatedPersistenceCandidate>(database: OpportunityPersistenceAdmissionPort, input: OpportunityPersistenceAdmissionInput<T>): Promise<OpportunityPersistenceAdmission<T>>;
-export interface EligibleStatusUpdateObserver {
-    onUnavailableAdapter?: () => void;
-}
-/**
- * Produces the guarded status-update handler used when dedup reactivates an
- * existing row. Existing non-introducer actor anchors are rechecked in the
- * same adapter operation as the status transition.
- */
-export declare function createEligibleOpportunityStatusUpdater(database: OpportunityPersistenceAdmissionPort, allowedNetworkIds: readonly Id<'networks'>[], networkEligibility: OpportunityNetworkEligibility, observer?: EligibleStatusUpdateObserver): (opportunityId: string, status: Opportunity['status'], existingActors: OpportunityActor[], expectedStatus: Opportunity['status']) => Promise<Opportunity | null>;
-export {};

package/dist/opportunities/opportunity.persistence-admission.js

@@ -1,59 +0,0 @@
-/**
- * Recomputes the owner-side scope at the final write boundary and removes
- * evaluator outputs whose actor/network anchors are no longer active.
- */
-export async function admitOpportunityPersistence(database, input) {
-    const memberships = await database.getNetworkMemberships(input.ownerUserId);
-    let allowedNetworkIds = memberships.map((membership) => membership.networkId);
-    if (input.triggerIntentId) {
-        const assignments = new Set(await database.getNetworkIdsForIntent(input.triggerIntentId));
-        allowedNetworkIds = allowedNetworkIds.filter((networkId) => assignments.has(networkId));
-    }
-    const explicitScope = input.networkId ? [input.networkId] : input.indexScope;
-    if (explicitScope !== undefined) {
-        const explicitlyAllowed = new Set(explicitScope);
-        allowedNetworkIds = allowedNetworkIds.filter((networkId) => explicitlyAllowed.has(networkId));
-    }
-    allowedNetworkIds = [...new Set(allowedNetworkIds)];
-    if (allowedNetworkIds.length === 0)
-        return { kind: 'empty_scope' };
-    const allowedNetworks = new Set(allowedNetworkIds);
-    const requestedPairs = input.evaluatedOpportunities.flatMap((evaluated) => evaluated.actors.flatMap((actor) => actor.networkId
-        ? [{ userId: actor.userId, networkId: actor.networkId }]
-        : []));
-    const activePairs = await database.getActiveNetworkMembershipPairs(requestedPairs);
-    const activePairKeys = new Set(activePairs.map((pair) => `${pair.userId}\u0000${pair.networkId}`));
-    const evaluatedOpportunities = input.evaluatedOpportunities.filter((evaluated) => evaluated.actors.length > 0
-        && evaluated.actors.every((actor) => actor.networkId != null
-            && allowedNetworks.has(actor.networkId)
-            && activePairKeys.has(`${actor.userId}\u0000${actor.networkId}`)));
-    return {
-        kind: 'admitted',
-        allowedNetworkIds,
-        networkEligibility: {
-            ownerUserId: input.ownerUserId,
-            allowedNetworkIds,
-            ...(input.triggerIntentId ? { triggerIntentId: input.triggerIntentId } : {}),
-        },
-        evaluatedOpportunities,
-    };
-}
-/**
- * Produces the guarded status-update handler used when dedup reactivates an
- * existing row. Existing non-introducer actor anchors are rechecked in the
- * same adapter operation as the status transition.
- */
-export function createEligibleOpportunityStatusUpdater(database, allowedNetworkIds, networkEligibility, observer) {
-    const allowedNetworks = new Set(allowedNetworkIds);
-    return async (opportunityId, status, existingActors, expectedStatus) => {
-        const anchors = existingActors.filter((actor) => actor.role !== 'introducer');
-        if (anchors.length === 0 || anchors.some((actor) => !allowedNetworks.has(actor.networkId))) {
-            return null;
-        }
-        if (!database.updateOpportunityStatusIfNetworkEligible) {
-            observer?.onUnavailableAdapter?.();
-            return null;
-        }
-        return database.updateOpportunityStatusIfNetworkEligible(opportunityId, status, anchors, networkEligibility, expectedStatus);
-    };
-}