@volley/sony-music-ingestion 1.0.72

package/dist/config/constants.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Configuration constants
+ */
+export declare const VOLLEY_PARTY_ID = "PADPIDA2019061409C";
+//# sourceMappingURL=constants.d.ts.map

package/dist/config/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/config/constants.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,eAAO,MAAM,eAAe,uBAAuB,CAAC"}

package/dist/config/constants.js

@@ -0,0 +1,7 @@
+"use strict";
+/**
+ * Configuration constants
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VOLLEY_PARTY_ID = void 0;
+exports.VOLLEY_PARTY_ID = "PADPIDA2019061409C";

package/dist/config/setup-localstack.js

@@ -0,0 +1,310 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupLocalStack = void 0;
+const aws_sdk_1 = require("aws-sdk");
+const ReleaseStorage_1 = require("../storage/dynamoDb/ReleaseStorage");
+const AtomFeedStorage_1 = require("../storage/s3/AtomFeedStorage");
+const MessageStorage_1 = require("../storage/s3/MessageStorage");
+const ResourceStorage_1 = require("../storage/s3/ResourceStorage");
+const DealStorage_1 = require("../storage/dynamoDb/DealStorage");
+const UnprocessedMessageStorage_1 = require("../storage/dynamoDb/UnprocessedMessageStorage");
+const child_process_1 = require("child_process");
+const http = __importStar(require("http"));
+const ENDPOINT = "http://localhost:4566";
+const REGION = "us-east-1";
+async function checkHealth() {
+    return new Promise((resolve) => {
+        const req = http.get(`${ENDPOINT}/_localstack/health`, (res) => {
+            resolve(res.statusCode === 200);
+        });
+        req.on("error", () => resolve(false));
+        req.setTimeout(2000, () => {
+            req.destroy();
+            resolve(false);
+        });
+    });
+}
+async function startLocalStack() {
+    console.log("Starting LocalStack...");
+    const child = (0, child_process_1.spawn)("localstack", ["start", "-d"], {
+        detached: true,
+        stdio: "ignore",
+    });
+    child.unref();
+    for (let i = 0; i < 30; i++) {
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+        if (await checkHealth()) {
+            console.log("Started LocalStack\n");
+            return;
+        }
+    }
+    throw new Error("Failed to start LocalStack");
+}
+async function ensureRunning() {
+    try {
+        (0, child_process_1.execSync)("which localstack", { stdio: "ignore" });
+    }
+    catch {
+        throw new Error("LocalStack not installed. Install: brew install localstack/tap/localstack-cli");
+    }
+    if (!(await checkHealth())) {
+        await startLocalStack();
+    }
+}
+async function ensureBucket(name) {
+    try {
+        (0, child_process_1.execSync)(`aws s3 mb s3://${name} --endpoint-url ${ENDPOINT} --region ${REGION}`, { stdio: "ignore" });
+        console.log(name + " ready");
+    }
+    catch (error) {
+    }
+}
+async function ensureReleasesTable(dynamodb) {
+    try {
+        await dynamodb
+            .describeTable({ TableName: ReleaseStorage_1.ReleaseStorage.TABLE_NAME })
+            .promise();
+        console.log(ReleaseStorage_1.ReleaseStorage.TABLE_NAME + "ready");
+    }
+    catch (error) {
+        if (error.code === "ResourceNotFoundException") {
+            await dynamodb
+                .createTable({
+                TableName: ReleaseStorage_1.ReleaseStorage.TABLE_NAME,
+                AttributeDefinitions: [
+                    { AttributeName: "GRid", AttributeType: "S" },
+                    { AttributeName: "MessageId", AttributeType: "S" },
+                    { AttributeName: "ISRC", AttributeType: "S" },
+                    { AttributeName: "Title", AttributeType: "S" },
+                    { AttributeName: "CatalogNumber", AttributeType: "S" },
+                    { AttributeName: "ICPN", AttributeType: "S" },
+                    { AttributeName: "Artist", AttributeType: "S" },
+                ],
+                KeySchema: [{ AttributeName: "GRid", KeyType: "HASH" }],
+                GlobalSecondaryIndexes: [
+                    {
+                        IndexName: "MessageId-index",
+                        KeySchema: [{ AttributeName: "MessageId", KeyType: "HASH" }],
+                        Projection: { ProjectionType: "ALL" },
+                        ProvisionedThroughput: {
+                            ReadCapacityUnits: 5,
+                            WriteCapacityUnits: 5,
+                        },
+                    },
+                    {
+                        IndexName: "ISRC-index",
+                        KeySchema: [{ AttributeName: "ISRC", KeyType: "HASH" }],
+                        Projection: { ProjectionType: "ALL" },
+                        ProvisionedThroughput: {
+                            ReadCapacityUnits: 5,
+                            WriteCapacityUnits: 5,
+                        },
+                    },
+                    {
+                        IndexName: "Title-index",
+                        KeySchema: [{ AttributeName: "Title", KeyType: "HASH" }],
+                        Projection: { ProjectionType: "ALL" },
+                        ProvisionedThroughput: {
+                            ReadCapacityUnits: 5,
+                            WriteCapacityUnits: 5,
+                        },
+                    },
+                    {
+                        IndexName: "CatalogNumber-index",
+                        KeySchema: [{ AttributeName: "CatalogNumber", KeyType: "HASH" }],
+                        Projection: { ProjectionType: "ALL" },
+                        ProvisionedThroughput: {
+                            ReadCapacityUnits: 5,
+                            WriteCapacityUnits: 5,
+                        },
+                    },
+                    {
+                        IndexName: "ICPN-index",
+                        KeySchema: [{ AttributeName: "ICPN", KeyType: "HASH" }],
+                        Projection: { ProjectionType: "ALL" },
+                        ProvisionedThroughput: {
+                            ReadCapacityUnits: 5,
+                            WriteCapacityUnits: 5,
+                        },
+                    },
+                    {
+                        IndexName: "Artist-Title-index",
+                        KeySchema: [
+                            { AttributeName: "Artist", KeyType: "HASH" },
+                            { AttributeName: "Title", KeyType: "RANGE" },
+                        ],
+                        Projection: { ProjectionType: "ALL" },
+                        ProvisionedThroughput: {
+                            ReadCapacityUnits: 5,
+                            WriteCapacityUnits: 5,
+                        },
+                    },
+                ],
+                ProvisionedThroughput: {
+                    ReadCapacityUnits: 5,
+                    WriteCapacityUnits: 5,
+                },
+            })
+                .promise();
+            await dynamodb
+                .waitFor("tableExists", { TableName: ReleaseStorage_1.ReleaseStorage.TABLE_NAME })
+                .promise();
+        }
+        else {
+            throw error;
+        }
+    }
+}
+async function ensureDealsTable(dynamodb) {
+    try {
+        await dynamodb
+            .describeTable({ TableName: DealStorage_1.DealStorage.TABLE_NAME })
+            .promise();
+        console.log(DealStorage_1.DealStorage.TABLE_NAME + "ready");
+    }
+    catch (error) {
+        if (error.code === "ResourceNotFoundException") {
+            await dynamodb
+                .createTable({
+                TableName: DealStorage_1.DealStorage.TABLE_NAME,
+                AttributeDefinitions: [
+                    { AttributeName: "isrc", AttributeType: "S" },
+                    { AttributeName: "dealHash", AttributeType: "S" },
+                ],
+                KeySchema: [
+                    { AttributeName: "isrc", KeyType: "HASH" },
+                    { AttributeName: "dealHash", KeyType: "RANGE" },
+                ],
+                ProvisionedThroughput: {
+                    ReadCapacityUnits: 5,
+                    WriteCapacityUnits: 5,
+                },
+            })
+                .promise();
+            await dynamodb
+                .waitFor("tableExists", { TableName: DealStorage_1.DealStorage.TABLE_NAME })
+                .promise();
+        }
+        else {
+            throw error;
+        }
+    }
+}
+async function ensureUnprocessedMessagesTable(dynamodb) {
+    try {
+        await dynamodb
+            .describeTable({ TableName: UnprocessedMessageStorage_1.UnprocessedMessageStorage.TABLE_NAME })
+            .promise();
+        console.log(UnprocessedMessageStorage_1.UnprocessedMessageStorage.TABLE_NAME + " ready");
+    }
+    catch (error) {
+        if (error.code === "ResourceNotFoundException") {
+            await dynamodb
+                .createTable({
+                TableName: UnprocessedMessageStorage_1.UnprocessedMessageStorage.TABLE_NAME,
+                AttributeDefinitions: [
+                    { AttributeName: "type", AttributeType: "S" },
+                    { AttributeName: "timestamp", AttributeType: "S" },
+                    { AttributeName: "uuid", AttributeType: "S" },
+                ],
+                KeySchema: [
+                    { AttributeName: "type", KeyType: "HASH" },
+                    { AttributeName: "timestamp", KeyType: "RANGE" },
+                ],
+                GlobalSecondaryIndexes: [
+                    {
+                        IndexName: "uuid-index",
+                        KeySchema: [{ AttributeName: "uuid", KeyType: "HASH" }],
+                        Projection: { ProjectionType: "KEYS_ONLY" },
+                        ProvisionedThroughput: {
+                            ReadCapacityUnits: 5,
+                            WriteCapacityUnits: 5,
+                        },
+                    },
+                    {
+                        IndexName: "uuid-timestamp-index",
+                        KeySchema: [
+                            { AttributeName: "uuid", KeyType: "HASH" },
+                            { AttributeName: "timestamp", KeyType: "RANGE" },
+                        ],
+                        Projection: { ProjectionType: "ALL" },
+                        ProvisionedThroughput: {
+                            ReadCapacityUnits: 5,
+                            WriteCapacityUnits: 5,
+                        },
+                    },
+                ],
+                ProvisionedThroughput: {
+                    ReadCapacityUnits: 5,
+                    WriteCapacityUnits: 5,
+                },
+            })
+                .promise();
+            await dynamodb
+                .waitFor("tableExists", { TableName: UnprocessedMessageStorage_1.UnprocessedMessageStorage.TABLE_NAME })
+                .promise();
+        }
+        else {
+            throw error;
+        }
+    }
+}
+async function setupLocalStack() {
+    const startTime = Date.now();
+    try {
+        await ensureRunning();
+        console.log(`LocalStack running (${Date.now() - startTime}ms)`);
+        const dynamodb = new aws_sdk_1.DynamoDB({
+            accessKeyId: "test",
+            secretAccessKey: "test",
+            endpoint: ENDPOINT,
+            region: REGION,
+        });
+        const buckets = [
+            AtomFeedStorage_1.AtomFeedStorage.BUCKET_NAME,
+            MessageStorage_1.MessageStorage.BUCKET_NAME,
+            ResourceStorage_1.ResourceStorage.BUCKET_NAME,
+        ];
+        await Promise.all([
+            ...buckets.map((name) => ensureBucket(name)),
+            ensureReleasesTable(dynamodb),
+            ensureDealsTable(dynamodb),
+            ensureUnprocessedMessagesTable(dynamodb),
+        ]);
+        console.log(`Endpoint: ${ENDPOINT}`);
+        console.log(`Region: ${REGION}\n`);
+    }
+    catch (error) {
+        console.error("\n✗ Setup failed:", error instanceof Error ? error.message : error);
+        throw error;
+    }
+}
+exports.setupLocalStack = setupLocalStack;
+if (require.main === module) {
+    setupLocalStack()
+        .then(() => process.exit(0))
+        .catch(() => process.exit(1));
+}

package/dist/core/ErnManager.d.ts

@@ -0,0 +1,59 @@
+import { TokenManager } from "./TokenManager";
+import { AtomFeedStorage } from "../storage/s3/AtomFeedStorage";
+import { MessageStorage } from "../storage/s3/MessageStorage";
+import { ReleaseStorage } from "../storage/dynamoDb/ReleaseStorage";
+import { DealStorage } from "../storage/dynamoDb/DealStorage";
+import { ResourceStorage } from "../storage/s3/ResourceStorage";
+import { UnprocessedMessageStorage } from "../storage/dynamoDb/UnprocessedMessageStorage";
+export interface ErnManagerConfig {
+    baseUrl: string;
+}
+/**
+ * Manages ATOM feed and ERN message lifecycle
+ * - Fetches ATOM feed with robust error handling
+ * - Downloads ERN messages
+ * - Sends acknowledgements
+ * - Comprehensive XML parsing
+ */
+export declare class ErnManager {
+    private readonly tokenManager;
+    private readonly atomFeedStorage;
+    private readonly messageStorage;
+    private readonly resourceStorage;
+    private readonly releaseStorage;
+    private readonly dealStorage;
+    private readonly unprocessedMessageStorage;
+    private readonly httpClient;
+    private readonly ernParser;
+    private nextExecution;
+    private readonly endpoint;
+    constructor(config: ErnManagerConfig, tokenManager: TokenManager, atomFeedStorage: AtomFeedStorage, messageStorage: MessageStorage, resourceStorage: ResourceStorage, releaseStorage: ReleaseStorage, dealStorage: DealStorage, unprocessedMessageStorage: UnprocessedMessageStorage);
+    start(): Promise<void>;
+    getFeed(id: any): Promise<string>;
+    private getUnprocessedMessages;
+    /**
+     * Fetch ATOM feed and return entries
+     */
+    private fetchAtomFeed;
+    /**
+     * Fetch the Ern message from the Atom feed.
+     */
+    private fetchErnMessage;
+    private processMessage;
+    /**
+     * Send acknowledgement for individual ERN message
+     *
+     * Per SME_04_ATOM_WS_Delivery.pdf Page 11, Section 4.2.1:
+     * - POST to the "Status" URL from the ATOM entry
+     * - Use ReleaseStatus: SuccessfullyIngestedByReleaseDistributor (success)
+     * - Use ReleaseStatus: ProcessingErrorAtReleaseDistributor (failure)
+     */
+    private acknowledgeMessage;
+    /**
+     * Build AcknowledgementMessage XML per DDEX ERN Choreography spec
+     *
+     * Per SME_04_ATOM_WS_Delivery.pdf Page 13-15, Section 5.3
+     */
+    private buildAcknowledgementMessage;
+}
+//# sourceMappingURL=ErnManager.d.ts.map

package/dist/core/ErnManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ErnManager.d.ts","sourceRoot":"","sources":["../../src/core/ErnManager.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAEpE,OAAO,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAC9D,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAEhE,OAAO,EAEL,yBAAyB,EAC1B,MAAM,+CAA+C,CAAC;AAOvD,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;GAMG;AACH,qBAAa,UAAU;IASnB,OAAO,CAAC,QAAQ,CAAC,YAAY;IAC7B,OAAO,CAAC,QAAQ,CAAC,eAAe;IAChC,OAAO,CAAC,QAAQ,CAAC,cAAc;IAC/B,OAAO,CAAC,QAAQ,CAAC,eAAe;IAChC,OAAO,CAAC,QAAQ,CAAC,cAAc;IAC/B,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,yBAAyB;IAd5C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA8C;IACzE,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAmB;IAC7C,OAAO,CAAC,aAAa,CAAK;IAE1B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;gBAGhC,MAAM,EAAE,gBAAgB,EACP,YAAY,EAAE,YAAY,EAC1B,eAAe,EAAE,eAAe,EAChC,cAAc,EAAE,cAAc,EAC9B,eAAe,EAAE,eAAe,EAChC,cAAc,EAAE,cAAc,EAC9B,WAAW,EAAE,WAAW,EACxB,yBAAyB,EAAE,yBAAyB;IAKjE,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAgDtB,OAAO,CAAC,EAAE,KAAA;YAIF,sBAAsB;IAWpC;;OAEG;YACW,aAAa;IAsB3B;;OAEG;YACW,eAAe;YAiCf,cAAc;IAqB5B;;;;;;;OAOG;YACW,kBAAkB;IAqChC;;;;OAIG;IACH,OAAO,CAAC,2BAA2B;CAyDpC"}

package/dist/core/ErnManager.js

@@ -0,0 +1,235 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErnManager = void 0;
+const BackoffHttpClient_1 = require("../http/BackoffHttpClient");
+const ErnParser_1 = require("./ErnParser");
+const constants_1 = require("../config/constants");
+const message_1 = require("../utils/message/message");
+const SECOND = 1000;
+const MINUTE = 60 * SECOND;
+const HOUR = 60 * MINUTE;
+/**
+ * Manages ATOM feed and ERN message lifecycle
+ * - Fetches ATOM feed with robust error handling
+ * - Downloads ERN messages
+ * - Sends acknowledgements
+ * - Comprehensive XML parsing
+ */
+class ErnManager {
+    constructor(config, tokenManager, atomFeedStorage, messageStorage, resourceStorage, releaseStorage, dealStorage, unprocessedMessageStorage) {
+        this.tokenManager = tokenManager;
+        this.atomFeedStorage = atomFeedStorage;
+        this.messageStorage = messageStorage;
+        this.resourceStorage = resourceStorage;
+        this.releaseStorage = releaseStorage;
+        this.dealStorage = dealStorage;
+        this.unprocessedMessageStorage = unprocessedMessageStorage;
+        this.httpClient = new BackoffHttpClient_1.BackoffHttpClient();
+        this.ernParser = new ErnParser_1.ErnParser();
+        this.nextExecution = 0;
+        this.endpoint = `${config.baseUrl}/gateway/ddex/ern/atom/feed/sort/date/${constants_1.VOLLEY_PARTY_ID}`;
+    }
+    async start() {
+        try {
+            console.log("Getting unprocessed messages");
+            const unprocessedMsgs = await this.getUnprocessedMessages();
+            console.log(`Processing ${unprocessedMsgs.length} unprocessed messages`);
+            for (const msg of unprocessedMsgs) {
+                await this.processMessage(msg);
+            }
+            console.log("Fetching feed");
+            const atomFeed = await this.fetchAtomFeed();
+            const hasAtomFeedMessages = atomFeed?.entries?.length > 0;
+            if (hasAtomFeedMessages) {
+                console.log(`Processing ${atomFeed.entries.length} messages`);
+                for (const entry of atomFeed.entries) {
+                    const ernMsg = await this.fetchErnMessage(entry);
+                    if (ernMsg) {
+                        await this.processMessage(ernMsg);
+                    }
+                }
+                this.nextExecution = 1 * MINUTE;
+            }
+            else {
+                console.log("No entries in feed");
+                this.nextExecution = 15 * MINUTE;
+            }
+        }
+        catch (error) {
+            console.log("Failed to fetch ATOM feed", error);
+            // Error - exponential backoff, max 3 hours
+            const newDelay = this.nextExecution > 0
+                ? Math.min(this.nextExecution ** 2 / SECOND, 3 * HOUR)
+                : 5 * SECOND;
+            this.nextExecution = newDelay;
+        }
+        finally {
+            // Always schedule next execution
+            const nextFetchTime = Date.now() + this.nextExecution;
+            console.log(`Next fetch at ${new Date(nextFetchTime).toISOString()} (${this.nextExecution / 1000}s)`);
+            setTimeout(() => this.start(), this.nextExecution);
+        }
+    }
+    async getFeed(id) {
+        return await this.atomFeedStorage.getFeed(id);
+    }
+    async getUnprocessedMessages() {
+        const unprocessedMetadata = await this.unprocessedMessageStorage.getUnprocessedMessageMetadata();
+        return await Promise.all(unprocessedMetadata.map(async (md) => this.messageStorage.getMessage(md.uuid)));
+    }
+    /**
+     * Fetch ATOM feed and return entries
+     */
+    async fetchAtomFeed() {
+        const token = await this.tokenManager.getToken();
+        const xmlString = await this.httpClient.get(this.endpoint, {
+            headers: {
+                Authorization: `Bearer ${token}`,
+            },
+        });
+        // Parse ATOM feed
+        const atomFeed = this.ernParser.parseAtomFeed(xmlString);
+        if (atomFeed.entries?.length > 0) {
+            // Save raw feed to Wasabi
+            await this.atomFeedStorage.saveFeed(atomFeed.id, xmlString);
+        }
+        else {
+            // TODO: logs and metrics
+            console.log("No entries");
+        }
+        return atomFeed;
+    }
+    /**
+     * Fetch the Ern message from the Atom feed.
+     */
+    async fetchErnMessage(entry) {
+        let ernMessage;
+        try {
+            const token = await this.tokenManager.getToken();
+            const xmlString = await this.httpClient.get(entry.releaseEndpoint, {
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                },
+            });
+            try {
+                ernMessage = this.ernParser.parseErnMessage(xmlString);
+                await this.messageStorage.saveMessage(ernMessage);
+                await this.unprocessedMessageStorage.saveUnprocessedMessage(ernMessage);
+                await this.acknowledgeMessage(entry, true, null);
+            }
+            catch (error) {
+                console.log("Failed to parse or save ERN message:", error);
+            }
+        }
+        catch (error) {
+            console.log("Failed to fetch ERN message:", error);
+            await this.acknowledgeMessage(entry, false, `${error}`);
+        }
+        return ernMessage;
+    }
+    async processMessage(ernMessage) {
+        try {
+            const messageId = (0, message_1.extractMessageId)(ernMessage);
+            console.log(`Saving ${messageId}`);
+            await Promise.all([
+                // Save resources to Wasabi S3
+                this.resourceStorage.saveResources(ernMessage),
+                // Save release metadata to DynamoDB
+                this.releaseStorage.saveReleases(ernMessage),
+                // Save deals
+                this.dealStorage.saveDeals(ernMessage),
+            ]);
+            console.log(`Finished saving ${messageId}`);
+            await this.unprocessedMessageStorage.markMessageProcessed(ernMessage);
+            console.log(`Marked processed ${messageId}`);
+        }
+        catch (error) {
+            // TODO: log this
+            console.log("Processing message error: ", error);
+        }
+    }
+    /**
+     * Send acknowledgement for individual ERN message
+     *
+     * Per SME_04_ATOM_WS_Delivery.pdf Page 11, Section 4.2.1:
+     * - POST to the "Status" URL from the ATOM entry
+     * - Use ReleaseStatus: SuccessfullyIngestedByReleaseDistributor (success)
+     * - Use ReleaseStatus: ProcessingErrorAtReleaseDistributor (failure)
+     */
+    async acknowledgeMessage(entry, success, errorText) {
+        if (!entry.ackEndpoint) {
+            console.log("No ack endpoint for entry:", entry.id);
+            return;
+        }
+        const token = await this.tokenManager.getToken();
+        const grid = entry.GRid;
+        const originalMessageId = entry.id;
+        const releaseStatus = success
+            ? "SuccessfullyIngestedByReleaseDistributor"
+            : "ProcessingErrorAtReleaseDistributor";
+        const ackMessage = this.buildAcknowledgementMessage(grid, originalMessageId, releaseStatus, errorText);
+        try {
+            await this.httpClient.post(entry.ackEndpoint, ackMessage, {
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                    "Content-Type": "application/xml",
+                },
+            });
+        }
+        catch (error) {
+            console.log(`Failed to acknowledge message ${originalMessageId}:`, error);
+        }
+    }
+    /**
+     * Build AcknowledgementMessage XML per DDEX ERN Choreography spec
+     *
+     * Per SME_04_ATOM_WS_Delivery.pdf Page 13-15, Section 5.3
+     */
+    buildAcknowledgementMessage(grid, originalMessageId, releaseStatus, errorText) {
+        const now = new Date().toISOString();
+        const ackMessageId = `${Date.now()}`;
+        let xml = `<?xml version="1.0"?>
+<ns3:AcknowledgementMessage xmlns:xs="http://www.w3.org/2001/XMLSchema-instance"
+ xmlns:ns3="http://ddex.net/xml/ern-c-sftp/18"
+ AvsVersionId="4">
+ <MessageHeader>
+ <MessageId>${ackMessageId}</MessageId>
+ <MessageSender>
+ <PartyId>${constants_1.VOLLEY_PARTY_ID}</PartyId>
+ <PartyName>
+ <FullName>Volley</FullName>
+ </PartyName>
+ </MessageSender>
+ <MessageRecipient>
+ <PartyId>PADPIDA2007040502I</PartyId>
+ <PartyName>
+ <FullName>Sony Music Entertainment</FullName>
+ </PartyName>
+ </MessageRecipient>
+ <MessageCreatedDateTime>${now}</MessageCreatedDateTime>
+ </MessageHeader>
+ <ReleaseStatus>
+ <ReleaseId>
+ <GRid>${grid}</GRid>
+ </ReleaseId>
+ <ReleaseStatus>${releaseStatus}</ReleaseStatus>`;
+        if (errorText) {
+            xml += `
+ <ErrorText>${errorText}</ErrorText>`;
+        }
+        xml += `
+ <Acknowledgement>
+ <MessageType>NewReleaseMessage</MessageType>
+ <MessageId>${originalMessageId}</MessageId>
+ <MessageStatus>
+ <Status>${releaseStatus === "SuccessfullyIngestedByReleaseDistributor"
+            ? "FileOK"
+            : "ProcessingError"}</Status>
+ </MessageStatus>
+ </Acknowledgement>
+ </ReleaseStatus>
+</ns3:AcknowledgementMessage>`;
+        return xml;
+    }
+}
+exports.ErnManager = ErnManager;

package/dist/core/ErnManager.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ErnManager.spec.d.ts.map

package/dist/core/ErnManager.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ErnManager.spec.d.ts","sourceRoot":"","sources":["../../src/core/ErnManager.spec.ts"],"names":[],"mappings":""}