zephyr-agent/dist/zephyr-engine/application-context.js

Zephyr plugin agent

"use strict";
var __webpack_require__ = {};
(()=>{
    __webpack_require__.d = (exports1, getters, values)=>{
        var define = (defs, kind)=>{
            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
                enumerable: true,
                [kind]: defs[key]
            });
        };
        define(getters, "get");
        define(values, "value");
    };
})();
(()=>{
    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
})();
(()=>{
    __webpack_require__.r = (exports1)=>{
        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
            value: 'Module'
        });
        Object.defineProperty(exports1, '__esModule', {
            value: true
        });
    };
})();
var __webpack_exports__ = {};
__webpack_require__.r(__webpack_exports__);
__webpack_require__.d(__webpack_exports__, {
    ApplicationContext: ()=>ApplicationContext,
    ApplicationContextRegistry: ()=>ApplicationContextRegistry
});
const external_build_session_js_namespaceObject = require("./build-session.js");
function buildDefinitionKey(options) {
    const participants = options.participants.map((participant)=>({
            name: participant.name,
            role: participant.role ?? participant.name,
            required: participant.required ?? true
        })).sort((left, right)=>left.name.localeCompare(right.name));
    const postprocessors = [
        ...options.postprocessors ?? []
    ].sort();
    return JSON.stringify({
        participants,
        postprocessors
    });
}
class ApplicationContext {
    applicationUid;
    options;
    latestGeneration = -1;
    activeSession = null;
    activeDefinitionKey = null;
    constructor(options){
        if (!options.applicationUid.trim()) throw new external_build_session_js_namespaceObject.BuildSessionStateError('Application UID must not be empty');
        this.applicationUid = options.applicationUid;
        this.options = options;
    }
    get currentBuild() {
        return this.activeSession;
    }
    beginBuild(options) {
        const definitionKey = buildDefinitionKey(options);
        const generation = options.generation ?? this.latestGeneration + 1;
        if (!Number.isSafeInteger(generation) || generation < 0) throw new external_build_session_js_namespaceObject.BuildSessionStateError(`Build generation must be a non-negative safe integer, received ${generation}`);
        const invocationId = options.invocationId ?? `invocation-${generation}`;
        if (!invocationId.trim()) throw new external_build_session_js_namespaceObject.BuildSessionStateError('Build invocation ID must not be empty');
        const active = this.activeSession;
        if (active?.failure instanceof external_build_session_js_namespaceObject.BuildSessionRollbackError) throw active.failure;
        if (active && active.identity.generation === generation && active.identity.invocationId === invocationId) {
            if (definitionKey !== this.activeDefinitionKey) throw new external_build_session_js_namespaceObject.BuildSessionStateError('Build participants or postprocessors differ for the same invocation generation');
            return active;
        }
        if (generation <= this.latestGeneration) throw new external_build_session_js_namespaceObject.BuildSessionStateError(`Build generation ${generation} is stale; latest generation is ${this.latestGeneration}`);
        if (active && !active.isTerminal) active.abort(`Superseded by build generation ${generation}`);
        const session = new external_build_session_js_namespaceObject.BuildSession({
            applicationUid: this.applicationUid,
            invocationId,
            generation
        }, options.participants, options.postprocessors ?? [], {
            prepare: this.options.prepare,
            publish: this.options.publish,
            finish: this.options.finish,
            onFailure: this.options.onFailure
        });
        this.latestGeneration = generation;
        this.activeSession = session;
        this.activeDefinitionKey = definitionKey;
        return session;
    }
    abortCurrent(reason) {
        const active = this.activeSession;
        if (active?.failure instanceof external_build_session_js_namespaceObject.BuildSessionRollbackError) throw active.failure;
        active?.abort(reason);
    }
}
class ApplicationContextRegistry {
    entries = new Map();
    pending = new Map();
    disposedPending = new WeakSet();
    getOrCreate(locator, create) {
        const aliases = this.createAliases(locator);
        const existingEntries = new Set(aliases.map((alias)=>this.entries.get(alias)).filter((entry)=>!!entry));
        if (existingEntries.size > 1) throw new external_build_session_js_namespaceObject.BuildSessionStateError('Application context aliases resolve to different registered contexts');
        let entry = existingEntries.values().next().value;
        if (!entry) {
            const context = create();
            entry = [
                ...new Set(this.entries.values())
            ].find((candidate)=>candidate.context === context) ?? {
                context,
                aliases: new Set()
            };
        }
        if (locator.applicationUid && entry.context.applicationUid !== locator.applicationUid) throw new external_build_session_js_namespaceObject.BuildSessionStateError(`Application context UID mismatch: expected ${locator.applicationUid}, received ${entry.context.applicationUid}`);
        for (const alias of aliases){
            const owner = this.entries.get(alias);
            if (owner && owner !== entry) throw new external_build_session_js_namespaceObject.BuildSessionStateError(`Application context alias "${alias}" is already registered`);
            entry.aliases.add(alias);
            this.entries.set(alias, entry);
        }
        return entry.context;
    }
    async getOrCreateAsync(locator, create) {
        const aliases = this.createAliases(locator);
        const existing = this.get(locator);
        if (existing) return existing;
        const pendingContexts = new Set(aliases.map((alias)=>this.pending.get(alias)).filter((context)=>!!context));
        if (pendingContexts.size > 1) throw new external_build_session_js_namespaceObject.BuildSessionStateError('Application context aliases have different pending initializations');
        let pendingContext = pendingContexts.values().next().value;
        if (!pendingContext) pendingContext = Promise.resolve().then(create);
        for (const alias of aliases){
            const owner = this.pending.get(alias);
            if (owner && owner !== pendingContext) throw new external_build_session_js_namespaceObject.BuildSessionStateError(`Application context alias "${alias}" is already initializing`);
            this.pending.set(alias, pendingContext);
        }
        try {
            const context = await pendingContext;
            if (this.disposedPending.has(pendingContext)) {
                context.abortCurrent('Context disposed during initialization');
                throw new external_build_session_js_namespaceObject.BuildSessionStateError('Application context was disposed during initialization');
            }
            this.clearPendingAliases(pendingContext);
            return this.getOrCreate(locator, ()=>context);
        } catch (error) {
            this.clearPendingAliases(pendingContext);
            throw error;
        }
    }
    get(locator) {
        const entries = new Set(this.createAliases(locator).map((alias)=>this.entries.get(alias)).filter((entry)=>!!entry));
        if (entries.size > 1) throw new external_build_session_js_namespaceObject.BuildSessionStateError('Application context aliases resolve to different registered contexts');
        return entries.values().next().value?.context ?? null;
    }
    associate(existing, aliases) {
        const context = this.get(existing);
        if (!context) throw new external_build_session_js_namespaceObject.BuildSessionStateError('Cannot associate an unknown application context');
        const aliasedContext = this.get(aliases);
        if (aliasedContext && aliasedContext !== context) throw new external_build_session_js_namespaceObject.BuildSessionStateError('Cannot associate aliases owned by a different application context');
        return this.getOrCreate(aliases, ()=>context);
    }
    dispose(locator, reason = 'Context disposed') {
        const aliases = this.createAliases(locator);
        const entry = aliases.map((alias)=>this.entries.get(alias)).find((candidate)=>!!candidate);
        if (!entry) {
            const pendingContext = aliases.map((alias)=>this.pending.get(alias)).find((context)=>!!context);
            if (!pendingContext) return false;
            this.disposedPending.add(pendingContext);
            this.clearPendingAliases(pendingContext);
            return true;
        }
        if (entry.context.currentBuild?.status !== 'publishing') entry.context.abortCurrent(reason);
        for (const alias of entry.aliases)this.entries.delete(alias);
        entry.aliases.clear();
        return true;
    }
    clear(reason = 'Registry cleared') {
        for (const pendingContext of new Set(this.pending.values()))this.disposedPending.add(pendingContext);
        this.pending.clear();
        const uniqueEntries = new Set(this.entries.values());
        for (const entry of uniqueEntries){
            if (entry.context.currentBuild?.status !== 'publishing') entry.context.abortCurrent(reason);
            entry.aliases.clear();
        }
        this.entries.clear();
    }
    clearPendingAliases(pendingContext) {
        for (const [alias, owner] of this.pending)if (owner === pendingContext) this.pending.delete(alias);
    }
    createAliases(locator) {
        const aliases = [];
        if (locator.contextKey?.trim()) aliases.push(`context:${locator.contextKey.trim()}`);
        if (locator.applicationUid || locator.invocationId) {
            if (!locator.applicationUid?.trim() || !locator.invocationId?.trim()) throw new external_build_session_js_namespaceObject.BuildSessionStateError('applicationUid and invocationId must be supplied together');
            aliases.push(`identity:${JSON.stringify([
                locator.applicationUid,
                locator.invocationId
            ])}`);
        }
        if (0 === aliases.length) throw new external_build_session_js_namespaceObject.BuildSessionStateError('An application/invocation identity or contextKey is required');
        return aliases;
    }
}
exports.ApplicationContext = __webpack_exports__.ApplicationContext;
exports.ApplicationContextRegistry = __webpack_exports__.ApplicationContextRegistry;
for(var __rspack_i in __webpack_exports__)if (-1 === [
    "ApplicationContext",
    "ApplicationContextRegistry"
].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
Object.defineProperty(exports, '__esModule', {
    value: true
});

//# sourceMappingURL=application-context.js.map