@casual-simulation/aux-records 3.4.6-alpha.14601027727 → 3.5.0-alpha.15117651144

package/webhooks/WebhookRecordsController.js

@@ -4,22 +4,12 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { DEFAULT_BRANCH_NAME, } from '@casual-simulation/aux-common';
-import { CrudRecordsController, } from '../crud/CrudRecordsController';
+import { DEFAULT_BRANCH_NAME, tryParseJson, } from '@casual-simulation/aux-common';
+import { CrudRecordsController } from '../crud/CrudRecordsController';
 import { getWebhookFeatures } from '../SubscriptionConfiguration';
 import { traced } from '../tracing/TracingDecorators';
 import { SpanStatusCode, trace } from '@opentelemetry/api';
-import { STORED_AUX_SCHEMA, } from './WebhookEnvironment';
-import { tryParseJson } from '../Utils';
+import { STORED_AUX_SCHEMA } from './WebhookEnvironment';
 import { v7 as uuidv7 } from 'uuid';
 import stringify from '@casual-simulation/fast-json-stable-stringify';
 import { sha256 } from 'hash.js';
@@ -34,7 +24,11 @@ export class WebhookRecordsController extends CrudRecordsController {
         return this._websockets;
     }
     constructor(config) {
-        super(Object.assign(Object.assign({}, config), { resourceKind: 'webhook', name: 'WebhookRecordsController' }));
+        super({
+            ...config,
+            resourceKind: 'webhook',
+            name: 'WebhookRecordsController',
+        });
         this._environment = config.environment;
         this._data = config.data;
         this._files = config.files;
@@ -45,433 +39,446 @@ export class WebhookRecordsController extends CrudRecordsController {
      * Handles a webhook request.
      * @param request The request to handle.
      */
-    handleWebhook(request) {
-        var _a, _b, _c, _d, _e;
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const requestTimeMs = Date.now();
-                const webhookContext = yield this.policies.constructAuthorizationContext({
-                    recordKeyOrRecordName: request.recordName,
-                    userId: request.userId,
-                });
-                if (webhookContext.success === false) {
-                    return webhookContext;
-                }
-                const recordName = webhookContext.context.recordName;
-                const webhook = yield this.store.getItemByAddress(recordName, request.address);
-                if (!webhook) {
+    async handleWebhook(request) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        try {
+            const requestTimeMs = Date.now();
+            const webhookContext = await this.policies.constructAuthorizationContext({
+                recordKeyOrRecordName: request.recordName,
+                userId: request.userId,
+            });
+            if (webhookContext.success === false) {
+                return webhookContext;
+            }
+            const recordName = webhookContext.context.recordName;
+            const webhook = await this.store.getItemByAddress(recordName, request.address);
+            if (!webhook) {
+                return {
+                    success: false,
+                    errorCode: 'not_found',
+                    errorMessage: 'Webhook not found.',
+                };
+            }
+            const webhookAuthorization = await this.policies.authorizeUserAndInstancesForResources(webhookContext.context, {
+                instances: request.instances,
+                userId: request.userId,
+                resources: [
+                    {
+                        resourceKind: 'webhook',
+                        resourceId: webhook.address,
+                        action: 'run',
+                        markers: webhook.markers,
+                    },
+                ],
+            });
+            if (webhookAuthorization.success === false) {
+                return webhookAuthorization;
+            }
+            const checkMetrics = await this._checkSubscriptionMetrics('run', webhookContext.context, webhookAuthorization, webhook);
+            if (checkMetrics.success === false) {
+                return checkMetrics;
+            }
+            let state;
+            const stateRecordName = webhook.targetRecordName;
+            let stateInstName = undefined;
+            if (webhook.targetResourceKind === 'data') {
+                if (!webhook.targetRecordName) {
                     return {
                         success: false,
-                        errorCode: 'not_found',
-                        errorMessage: 'Webhook not found.',
+                        errorCode: 'invalid_webhook_target',
+                        errorMessage: 'Invalid webhook target. The targeted record does not contain a valid name.',
                     };
                 }
-                const webhookAuthorization = yield this.policies.authorizeUserAndInstancesForResources(webhookContext.context, {
-                    instances: request.instances,
-                    userId: request.userId,
-                    resources: [
-                        {
-                            resourceKind: 'webhook',
-                            resourceId: webhook.address,
-                            action: 'run',
-                            markers: webhook.markers,
-                        },
-                    ],
-                });
-                if (webhookAuthorization.success === false) {
-                    return webhookAuthorization;
-                }
-                const checkMetrics = yield this._checkSubscriptionMetrics('run', webhookContext.context, webhookAuthorization, webhook);
-                if (checkMetrics.success === false) {
-                    return checkMetrics;
-                }
-                let state = null;
-                const stateRecordName = webhook.targetRecordName;
-                let stateInstName = undefined;
-                if (webhook.targetResourceKind === 'data') {
-                    const data = yield this._data.getData(webhook.targetRecordName, webhook.targetAddress, webhook.userId, request.instances);
-                    if (data.success === false) {
-                        return {
-                            success: false,
-                            errorCode: 'invalid_webhook_target',
-                            errorMessage: 'Invalid webhook target. The targeted record was not able to be retrieved.',
-                            internalError: data,
-                        };
-                    }
-                    let auxData;
-                    if (typeof data.data === 'string') {
-                        const stored = tryParseJson(data.data);
-                        if (stored.success === true) {
-                            auxData = stored.value;
-                        }
-                    }
-                    else if (typeof data.data === 'object') {
-                        auxData = data.data;
-                    }
-                    const parseResult = STORED_AUX_SCHEMA.safeParse(auxData);
-                    if (parseResult.success === false) {
-                        return {
-                            success: false,
-                            errorCode: 'invalid_webhook_target',
-                            errorMessage: 'Invalid webhook target. The targeted record does not contain valid data.',
-                            internalError: {
-                                success: false,
-                                errorCode: 'unacceptable_request',
-                                errorMessage: 'The data record does not contain valid AUX data.',
-                                issues: parseResult.error.issues,
-                            },
-                        };
-                    }
-                    state = {
-                        type: 'aux',
-                        state: parseResult.data,
+                const data = await this._data.getData(webhook.targetRecordName, webhook.targetAddress, webhook.userId, request.instances);
+                if (data.success === false) {
+                    return {
+                        success: false,
+                        errorCode: 'invalid_webhook_target',
+                        errorMessage: 'Invalid webhook target. The targeted record was not able to be retrieved.',
+                        internalError: data,
                     };
                 }
-                else if (webhook.targetResourceKind === 'file') {
-                    const file = yield this._files.readFile(webhook.targetRecordName, webhook.targetAddress, webhook.userId, request.instances);
-                    if (file.success === false) {
-                        return {
-                            success: false,
-                            errorCode: 'invalid_webhook_target',
-                            errorMessage: 'Invalid webhook target. The targeted record was not able to be retrieved.',
-                            internalError: file,
-                        };
+                let auxData;
+                if (typeof data.data === 'string') {
+                    const stored = tryParseJson(data.data);
+                    if (stored.success === true) {
+                        auxData = stored.value;
                     }
-                    state = {
-                        type: 'url',
-                        requestUrl: file.requestUrl,
-                        requestMethod: file.requestMethod,
-                        requestHeaders: file.requestHeaders,
-                    };
                 }
-                else if (webhook.targetResourceKind === 'inst') {
-                    if (!this._websockets) {
-                        return {
-                            success: false,
-                            errorCode: 'invalid_webhook_target',
-                            errorMessage: 'Invalid webhook target. Inst records are not supported in this environment.',
-                            internalError: {
-                                success: false,
-                                errorCode: 'not_supported',
-                                errorMessage: 'Inst records are not supported in this environment.',
-                            },
-                        };
-                    }
-                    const inst = yield this._websockets.getBranchData(webhook.userId, webhook.targetRecordName, webhook.targetAddress, DEFAULT_BRANCH_NAME, 2);
-                    if (inst.success === false) {
-                        return {
-                            success: false,
-                            errorCode: 'invalid_webhook_target',
-                            errorMessage: 'Invalid webhook target. The targeted record was not able to be retrieved.',
-                            internalError: inst,
-                        };
-                    }
-                    stateInstName = webhook.targetAddress;
-                    state = {
-                        type: 'aux',
-                        state: inst.data,
-                    };
+                else if (typeof data.data === 'object') {
+                    auxData = data.data;
                 }
-                if (!state) {
+                const parseResult = STORED_AUX_SCHEMA.safeParse(auxData);
+                if (parseResult.success === false) {
                     return {
                         success: false,
                         errorCode: 'invalid_webhook_target',
-                        errorMessage: 'Invalid webhook target. The targeted record does not contain a valid AUX.',
+                        errorMessage: 'Invalid webhook target. The targeted record does not contain valid data.',
+                        internalError: {
+                            success: false,
+                            errorCode: 'unacceptable_request',
+                            errorMessage: 'The data record does not contain valid AUX data.',
+                            issues: parseResult.error.issues,
+                        },
                     };
                 }
-                let sessionUserId;
-                let sessionKey;
-                let connectionKey;
-                if (webhook.userId) {
-                    // Create a session for the user
-                    const issueSessionResult = yield this._auth.issueSession({
-                        userId: webhook.userId,
-                        requestingUserId: null,
-                        requestingUserRole: 'system',
-                        ipAddress: null,
-                        lifetimeMs: (_a = checkMetrics.features.tokenLifetimeMs) !== null && _a !== void 0 ? _a : 5 * 60 * 1000,
-                    });
-                    if (issueSessionResult.success === true) {
-                        sessionUserId = issueSessionResult.userId;
-                        sessionKey = issueSessionResult.sessionKey;
-                        connectionKey = issueSessionResult.connectionKey;
-                    }
-                    else {
-                        console.warn('[WebhookRecordsController] Error issuing session for webhook:', issueSessionResult);
-                    }
-                }
-                const options = {
-                    initTimeoutMs: (_b = checkMetrics.features.initTimeoutMs) !== null && _b !== void 0 ? _b : 5000,
-                    requestTimeoutMs: (_c = checkMetrics.features.requestTimeoutMs) !== null && _c !== void 0 ? _c : 5000,
-                    fetchTimeoutMs: (_d = checkMetrics.features.fetchTimeoutMs) !== null && _d !== void 0 ? _d : 5000,
-                    addStateTimeoutMs: (_e = checkMetrics.features.addStateTimeoutMs) !== null && _e !== void 0 ? _e : 1000,
+                state = {
+                    type: 'aux',
+                    state: parseResult.data,
                 };
-                const result = yield this._environment.handleHttpRequest({
-                    state: state,
-                    recordName: stateRecordName,
-                    inst: stateInstName,
-                    request: request.request,
-                    requestUserId: request.userId,
-                    sessionUserId,
-                    sessionKey,
-                    connectionKey,
-                    options,
-                });
-                const responseTimeMs = Date.now();
-                const stateHash = getHash(state);
-                const runId = uuidv7();
-                let infoFileName = null;
-                let infoRecordName = null;
-                if (webhook.userId) {
-                    const recordName = webhook.userId;
-                    const dataFile = {
-                        runId,
-                        version: 1,
-                        request: request.request,
-                        requestUserId: request.userId,
-                        response: result.success === true ? result.response : null,
-                        logs: result.success === true ? result.logs : [],
-                        state,
-                        stateSha256: stateHash,
-                        authorization: webhookAuthorization,
+            }
+            else if (webhook.targetResourceKind === 'file') {
+                if (!webhook.targetRecordName) {
+                    return {
+                        success: false,
+                        errorCode: 'invalid_webhook_target',
+                        errorMessage: 'Invalid webhook target. The targeted record does not contain a valid name.',
                     };
-                    const json = stringify(dataFile);
-                    const data = new TextEncoder().encode(json);
-                    const recordResult = yield this._files.recordFile(recordName, recordName, {
-                        fileSha256Hex: sha256().update(data).digest('hex'),
-                        fileByteLength: data.byteLength,
-                        fileDescription: `Webhook data for run ${runId}`,
-                        fileMimeType: 'application/json',
-                        headers: {},
-                        markers: [`private:logs`],
-                    });
-                    if (recordResult.success === false) {
-                        console.error('[WebhookRecordsController] Error recording webhook info file:', recordResult);
-                    }
-                    else {
-                        infoRecordName = recordName;
-                        infoFileName = recordResult.fileName;
-                        const requestResult = yield axios.request({
-                            method: recordResult.uploadMethod,
-                            headers: recordResult.uploadHeaders,
-                            url: recordResult.uploadUrl,
-                            data: data,
-                            validateStatus: () => true,
-                        });
-                        if (requestResult.status <= 199 ||
-                            requestResult.status >= 300) {
-                            console.error('[WebhookRecordsController] Error uploading webhook info file:', requestResult);
-                        }
-                    }
                 }
-                const run = {
-                    runId: uuidv7(),
-                    recordName: recordName,
-                    webhookAddress: request.address,
-                    errorResult: result.success === false ? result : null,
-                    requestTimeMs,
-                    responseTimeMs,
-                    statusCode: result.success === true ? result.response.statusCode : null,
-                    stateSha256: stateHash,
-                    infoRecordName,
-                    infoFileName,
-                    options,
-                };
-                yield this.store.recordWebhookRun(run);
-                if (result.success === true) {
+                const file = await this._files.readFile(webhook.targetRecordName, webhook.targetAddress, (_a = webhook.userId) !== null && _a !== void 0 ? _a : null, request.instances);
+                if (file.success === false) {
                     return {
-                        success: true,
-                        response: result.response,
+                        success: false,
+                        errorCode: 'invalid_webhook_target',
+                        errorMessage: 'Invalid webhook target. The targeted record was not able to be retrieved.',
+                        internalError: file,
                     };
                 }
-                else {
-                    return result;
-                }
-            }
-            catch (err) {
-                const span = trace.getActiveSpan();
-                span === null || span === void 0 ? void 0 : span.recordException(err);
-                span === null || span === void 0 ? void 0 : span.setStatus({ code: SpanStatusCode.ERROR });
-                console.error('[WebhookRecordsController] Error handling webhook:', err);
-                return {
-                    success: false,
-                    errorCode: 'server_error',
-                    errorMessage: 'A server error occurred.',
+                state = {
+                    type: 'url',
+                    requestUrl: file.requestUrl,
+                    requestMethod: file.requestMethod,
+                    requestHeaders: file.requestHeaders,
                 };
             }
-        });
-    }
-    listWebhookRuns(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const context = yield this.policies.constructAuthorizationContext({
-                    userId: request.userId,
-                    recordKeyOrRecordName: request.recordName,
-                });
-                if (context.success === false) {
-                    return context;
-                }
-                const recordName = context.context.recordName;
-                const webhook = yield this.store.getItemByAddress(recordName, request.address);
-                if (!webhook) {
+            else if (webhook.targetResourceKind === 'inst') {
+                if (!this._websockets) {
                     return {
                         success: false,
-                        errorCode: 'data_not_found',
-                        errorMessage: 'The webhook was not found.',
+                        errorCode: 'invalid_webhook_target',
+                        errorMessage: 'Invalid webhook target. Inst records are not supported in this environment.',
+                        internalError: {
+                            success: false,
+                            errorCode: 'not_supported',
+                            errorMessage: 'Inst records are not supported in this environment.',
+                        },
                     };
                 }
-                const authorization = yield this.policies.authorizeUserAndInstancesForResources(context.context, {
-                    instances: request.instances,
-                    userId: context.context.userId,
-                    resources: [
-                        {
-                            resourceKind: 'webhook',
-                            resourceId: webhook.address,
-                            action: 'read',
-                            markers: webhook.markers,
-                        },
-                    ],
-                });
-                if (authorization.success === false) {
-                    return authorization;
+                const inst = await this._websockets.getBranchData((_b = webhook.userId) !== null && _b !== void 0 ? _b : null, webhook.targetRecordName, webhook.targetAddress, DEFAULT_BRANCH_NAME, 2);
+                if (inst.success === false) {
+                    return {
+                        success: false,
+                        errorCode: 'invalid_webhook_target',
+                        errorMessage: 'Invalid webhook target. The targeted record was not able to be retrieved.',
+                        internalError: inst,
+                    };
                 }
-                const runs = yield this.store.listWebhookRunsForWebhook(recordName, request.address, request.requestTimeMs);
-                return {
-                    success: true,
-                    recordName: recordName,
-                    items: runs.items,
-                    totalCount: runs.totalCount,
-                    marker: runs.marker,
+                stateInstName = webhook.targetAddress;
+                state = {
+                    type: 'aux',
+                    state: inst.data,
                 };
             }
-            catch (err) {
-                const span = trace.getActiveSpan();
-                span === null || span === void 0 ? void 0 : span.recordException(err);
-                span === null || span === void 0 ? void 0 : span.setStatus({ code: SpanStatusCode.ERROR });
-                console.error('[WebhookRecordsController] Error listing webhook runs:', err);
+            else {
                 return {
                     success: false,
-                    errorCode: 'server_error',
-                    errorMessage: 'A server error occurred.',
+                    errorCode: 'invalid_webhook_target',
+                    errorMessage: 'Invalid webhook target. The targeted record does not contain a valid AUX.',
                 };
             }
-        });
-    }
-    getWebhookRun(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const run = yield this.store.getWebhookRunInfo(request.runId);
-                if (!run) {
-                    return {
-                        success: false,
-                        errorCode: 'data_not_found',
-                        errorMessage: 'The webhook run was not found.',
-                    };
-                }
-                const context = yield this.policies.constructAuthorizationContext({
-                    userId: request.userId,
-                    recordKeyOrRecordName: run.run.recordName,
+            let sessionUserId = undefined;
+            let sessionKey = undefined;
+            let connectionKey = undefined;
+            if (webhook.userId) {
+                // Create a session for the user
+                const issueSessionResult = await this._auth.issueSession({
+                    userId: webhook.userId,
+                    requestingUserId: null,
+                    requestingUserRole: 'system',
+                    ipAddress: null,
+                    lifetimeMs: (_c = checkMetrics.features.tokenLifetimeMs) !== null && _c !== void 0 ? _c : 5 * 60 * 1000,
                 });
-                if (context.success === false) {
-                    return context;
+                if (issueSessionResult.success === true) {
+                    sessionUserId = issueSessionResult.userId;
+                    sessionKey = issueSessionResult.sessionKey;
+                    connectionKey = issueSessionResult.connectionKey;
+                }
+                else {
+                    console.warn('[WebhookRecordsController] Error issuing session for webhook:', issueSessionResult);
                 }
-                const authorization = yield this.policies.authorizeUserAndInstances(context.context, {
-                    action: 'read',
-                    resourceKind: 'webhook',
-                    resourceId: run.webhook.address,
-                    markers: run.webhook.markers,
-                    instances: request.instances,
-                    userId: context.context.userId,
+            }
+            const options = {
+                initTimeoutMs: (_d = checkMetrics.features.initTimeoutMs) !== null && _d !== void 0 ? _d : 5000,
+                requestTimeoutMs: (_e = checkMetrics.features.requestTimeoutMs) !== null && _e !== void 0 ? _e : 5000,
+                fetchTimeoutMs: (_f = checkMetrics.features.fetchTimeoutMs) !== null && _f !== void 0 ? _f : 5000,
+                addStateTimeoutMs: (_g = checkMetrics.features.addStateTimeoutMs) !== null && _g !== void 0 ? _g : 1000,
+            };
+            const result = await this._environment.handleHttpRequest({
+                state: state,
+                recordName: stateRecordName,
+                inst: stateInstName,
+                request: request.request,
+                requestUserId: request.userId,
+                sessionUserId,
+                sessionKey,
+                connectionKey,
+                options,
+            });
+            const responseTimeMs = Date.now();
+            const stateHash = getHash(state);
+            const runId = uuidv7();
+            let infoFileName = null;
+            let infoRecordName = null;
+            if (webhook.userId) {
+                const recordName = webhook.userId;
+                const dataFile = {
+                    runId,
+                    version: 1,
+                    request: request.request,
+                    requestUserId: request.userId,
+                    response: result.success === true ? result.response : null,
+                    logs: result.success === true ? result.logs : [],
+                    state,
+                    stateSha256: stateHash,
+                    authorization: webhookAuthorization,
+                };
+                const json = stringify(dataFile);
+                const data = new TextEncoder().encode(json);
+                const recordResult = await this._files.recordFile(recordName, recordName, {
+                    fileSha256Hex: sha256().update(data).digest('hex'),
+                    fileByteLength: data.byteLength,
+                    fileDescription: `Webhook data for run ${runId}`,
+                    fileMimeType: 'application/json',
+                    headers: {},
+                    markers: [`private:logs`],
                 });
-                if (authorization.success === false) {
-                    return authorization;
+                if (recordResult.success === false) {
+                    console.error('[WebhookRecordsController] Error recording webhook info file:', recordResult);
                 }
-                let infoFileResult = null;
-                if (run.run.infoRecordName && run.run.infoFileName) {
-                    infoFileResult = yield this._files.readFile(run.run.infoRecordName, run.run.infoFileName, run.webhook.userId, request.instances);
+                else {
+                    infoRecordName = recordName;
+                    infoFileName = recordResult.fileName;
+                    const requestResult = await axios.request({
+                        method: recordResult.uploadMethod,
+                        headers: recordResult.uploadHeaders,
+                        url: recordResult.uploadUrl,
+                        data: data,
+                        validateStatus: () => true,
+                    });
+                    if (requestResult.status <= 199 ||
+                        requestResult.status >= 300) {
+                        console.error('[WebhookRecordsController] Error uploading webhook info file:', requestResult);
+                    }
                 }
+            }
+            const run = {
+                runId: uuidv7(),
+                recordName: recordName,
+                webhookAddress: request.address,
+                errorResult: result.success === false ? result : null,
+                requestTimeMs,
+                responseTimeMs,
+                statusCode: result.success === true ? result.response.statusCode : null,
+                stateSha256: stateHash,
+                infoRecordName,
+                infoFileName,
+                options,
+            };
+            await this.store.recordWebhookRun(run);
+            if (result.success === true) {
                 return {
                     success: true,
-                    run: run.run,
-                    infoFileResult,
+                    response: result.response,
                 };
             }
-            catch (err) {
-                const span = trace.getActiveSpan();
+            else {
+                return result;
+            }
+        }
+        catch (err) {
+            const span = trace.getActiveSpan();
+            if (err instanceof Error) {
                 span === null || span === void 0 ? void 0 : span.recordException(err);
-                span === null || span === void 0 ? void 0 : span.setStatus({ code: SpanStatusCode.ERROR });
-                console.error('[WebhookRecordsController] Error getting webhook run:', err);
+            }
+            span === null || span === void 0 ? void 0 : span.setStatus({ code: SpanStatusCode.ERROR });
+            console.error('[WebhookRecordsController] Error handling webhook:', err);
+            return {
+                success: false,
+                errorCode: 'server_error',
+                errorMessage: 'A server error occurred.',
+            };
+        }
+    }
+    async listWebhookRuns(request) {
+        try {
+            const context = await this.policies.constructAuthorizationContext({
+                userId: request.userId,
+                recordKeyOrRecordName: request.recordName,
+            });
+            if (context.success === false) {
+                return context;
+            }
+            const recordName = context.context.recordName;
+            const webhook = await this.store.getItemByAddress(recordName, request.address);
+            if (!webhook) {
                 return {
                     success: false,
-                    errorCode: 'server_error',
-                    errorMessage: 'A server error occurred.',
+                    errorCode: 'data_not_found',
+                    errorMessage: 'The webhook was not found.',
                 };
             }
-        });
-    }
-    _checkSubscriptionMetrics(action, context, authorization, item) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const config = yield this.config.getSubscriptionConfiguration();
-            const metrics = yield this.store.getSubscriptionMetrics({
-                ownerId: context.recordOwnerId,
-                studioId: context.recordStudioId,
+            const authorization = await this.policies.authorizeUserAndInstancesForResources(context.context, {
+                instances: request.instances,
+                userId: context.context.userId,
+                resources: [
+                    {
+                        resourceKind: 'webhook',
+                        resourceId: webhook.address,
+                        action: 'read',
+                        markers: webhook.markers,
+                    },
+                ],
             });
-            const features = getWebhookFeatures(config, metrics.subscriptionStatus, metrics.subscriptionId, metrics.subscriptionType);
-            if (!features.allowed) {
+            if (authorization.success === false) {
+                return authorization;
+            }
+            const runs = await this.store.listWebhookRunsForWebhook(recordName, request.address, request.requestTimeMs);
+            return {
+                success: true,
+                recordName: recordName,
+                items: runs.items,
+                totalCount: runs.totalCount,
+                marker: runs.marker,
+            };
+        }
+        catch (err) {
+            const span = trace.getActiveSpan();
+            if (err instanceof Error) {
+                span === null || span === void 0 ? void 0 : span.recordException(err);
+            }
+            span === null || span === void 0 ? void 0 : span.setStatus({ code: SpanStatusCode.ERROR });
+            console.error('[WebhookRecordsController] Error listing webhook runs:', err);
+            return {
+                success: false,
+                errorCode: 'server_error',
+                errorMessage: 'A server error occurred.',
+            };
+        }
+    }
+    async getWebhookRun(request) {
+        var _a;
+        try {
+            const run = await this.store.getWebhookRunInfo(request.runId);
+            if (!run) {
                 return {
                     success: false,
-                    errorCode: 'not_authorized',
-                    errorMessage: 'Webhooks are not allowed for this subscription.',
+                    errorCode: 'data_not_found',
+                    errorMessage: 'The webhook run was not found.',
                 };
             }
-            if (action === 'create' && typeof features.maxItems === 'number') {
-                if (metrics.totalItems >= features.maxItems) {
-                    return {
-                        success: false,
-                        errorCode: 'subscription_limit_reached',
-                        errorMessage: 'The maximum number of webhook items has been reached for your subscription.',
-                    };
-                }
+            const context = await this.policies.constructAuthorizationContext({
+                userId: request.userId,
+                recordKeyOrRecordName: run.run.recordName,
+            });
+            if (context.success === false) {
+                return context;
             }
-            if (action === 'create') {
-                // create a user for the webhook
-                if (!item.userId) {
-                    const result = yield this._auth.createAccount({
-                        userRole: 'superUser', // The system gets superUser permissions when performing administrative tasks
-                        ipAddress: null,
-                        createSession: false,
-                    });
-                    if (result.success === false) {
-                        return result;
-                    }
-                    else {
-                        item.userId = result.userId;
-                    }
-                }
+            const authorization = await this.policies.authorizeUserAndInstances(context.context, {
+                action: 'read',
+                resourceKind: 'webhook',
+                resourceId: run.webhook.address,
+                markers: run.webhook.markers,
+                instances: request.instances,
+                userId: context.context.userId,
+            });
+            if (authorization.success === false) {
+                return authorization;
             }
-            if (action === 'run') {
-                if (typeof features.maxRunsPerPeriod === 'number' &&
-                    metrics.totalRunsInPeriod >= features.maxRunsPerPeriod) {
-                    return {
-                        success: false,
-                        errorCode: 'subscription_limit_reached',
-                        errorMessage: 'The maximum number of webhook runs has been reached for your subscription.',
-                    };
-                }
-                if (typeof features.maxRunsPerHour === 'number' &&
-                    metrics.totalRunsInLastHour >= features.maxRunsPerHour) {
-                    return {
-                        success: false,
-                        errorCode: 'subscription_limit_reached',
-                        errorMessage: 'The maximum number of webhook runs has been reached for your subscription.',
-                    };
-                }
+            let infoFileResult = null;
+            if (run.run.infoRecordName && run.run.infoFileName) {
+                infoFileResult = await this._files.readFile(run.run.infoRecordName, run.run.infoFileName, (_a = run.webhook.userId) !== null && _a !== void 0 ? _a : null, request.instances);
             }
             return {
                 success: true,
-                features,
+                run: run.run,
+                infoFileResult,
+            };
+        }
+        catch (err) {
+            const span = trace.getActiveSpan();
+            if (err instanceof Error) {
+                span === null || span === void 0 ? void 0 : span.recordException(err);
+            }
+            span === null || span === void 0 ? void 0 : span.setStatus({ code: SpanStatusCode.ERROR });
+            console.error('[WebhookRecordsController] Error getting webhook run:', err);
+            return {
+                success: false,
+                errorCode: 'server_error',
+                errorMessage: 'A server error occurred.',
             };
+        }
+    }
+    async _checkSubscriptionMetrics(action, context, authorization, item) {
+        const config = await this.config.getSubscriptionConfiguration();
+        const metrics = await this.store.getSubscriptionMetrics({
+            ownerId: context.recordOwnerId,
+            studioId: context.recordStudioId,
         });
+        const features = getWebhookFeatures(config, metrics.subscriptionStatus, metrics.subscriptionId, metrics.subscriptionType);
+        if (!features.allowed) {
+            return {
+                success: false,
+                errorCode: 'not_authorized',
+                errorMessage: 'Webhooks are not allowed for this subscription.',
+            };
+        }
+        if (action === 'create' && typeof features.maxItems === 'number') {
+            if (metrics.totalItems >= features.maxItems) {
+                return {
+                    success: false,
+                    errorCode: 'subscription_limit_reached',
+                    errorMessage: 'The maximum number of webhook items has been reached for your subscription.',
+                };
+            }
+        }
+        if (action === 'create') {
+            // create a user for the webhook
+            if (item && !item.userId) {
+                const result = await this._auth.createAccount({
+                    userRole: 'superUser', // The system gets superUser permissions when performing administrative tasks
+                    ipAddress: null,
+                    createSession: false,
+                });
+                if (result.success === false) {
+                    return result;
+                }
+                else {
+                    item.userId = result.userId;
+                }
+            }
+        }
+        if (action === 'run') {
+            if (typeof features.maxRunsPerPeriod === 'number' &&
+                metrics.totalRunsInPeriod >= features.maxRunsPerPeriod) {
+                return {
+                    success: false,
+                    errorCode: 'subscription_limit_reached',
+                    errorMessage: 'The maximum number of webhook runs has been reached for your subscription.',
+                };
+            }
+            if (typeof features.maxRunsPerHour === 'number' &&
+                metrics.totalRunsInLastHour >= features.maxRunsPerHour) {
+                return {
+                    success: false,
+                    errorCode: 'subscription_limit_reached',
+                    errorMessage: 'The maximum number of webhook runs has been reached for your subscription.',
+                };
+            }
+        }
+        return {
+            success: true,
+            features,
+        };
     }
     _transformInputItem(item) {
         delete item.userId;