@omen.foundation/node-microservice-runtime 0.1.76 → 0.1.77

package/dist/inventory.cjs

@@ -0,0 +1,361 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InventoryService = exports.InventoryUpdateBuilder = void 0;
+exports.createInventoryService = createInventoryService;
+const node_crypto_1 = require("node:crypto");
+const errors_js_1 = require("./errors.js");
+class InventoryUpdateBuilder {
+    constructor() {
+        this.currencyChanges = new Map();
+        this.currencyPropertyUpdates = new Map();
+        this.newItemRequests = [];
+        this.deleteItemRequests = [];
+        this.updateItemRequests = [];
+    }
+    applyVipBonus(apply) {
+        this.applyVipBonusFlag = apply;
+        return this;
+    }
+    currencyChange(currencyId, delta) {
+        var _a;
+        const normalizedId = this.normalizeId(currencyId, 'currency');
+        const current = (_a = this.currencyChanges.get(normalizedId)) !== null && _a !== void 0 ? _a : BigInt(0);
+        const next = current + BigInt(delta);
+        if (next === BigInt(0)) {
+            this.currencyChanges.delete(normalizedId);
+        }
+        else {
+            this.currencyChanges.set(normalizedId, next);
+        }
+        return this;
+    }
+    setCurrencyProperties(currencyId, properties) {
+        const normalizedId = this.normalizeId(currencyId, 'currency');
+        this.currencyPropertyUpdates.set(normalizedId, [...properties]);
+        return this;
+    }
+    addItem(contentId, properties = {}, requestId = (0, node_crypto_1.randomUUID)()) {
+        const normalizedId = this.normalizeId(contentId, 'item');
+        const itemProperties = Object.entries(properties).map(([name, value]) => ({
+            name,
+            value,
+        }));
+        this.newItemRequests.push({
+            contentId: normalizedId,
+            properties: itemProperties,
+            reqId: requestId,
+        });
+        return this;
+    }
+    deleteItem(contentId, itemId) {
+        const normalizedId = this.normalizeId(contentId, 'item');
+        this.deleteItemRequests.push({
+            contentId: normalizedId,
+            id: this.toIdentifier(itemId),
+        });
+        return this;
+    }
+    updateItem(contentId, itemId, properties) {
+        const normalizedId = this.normalizeId(contentId, 'item');
+        const normalizedProperties = Object.entries(properties).map(([name, value]) => ({
+            name,
+            value,
+        }));
+        this.updateItemRequests.push({
+            contentId: normalizedId,
+            id: this.toIdentifier(itemId),
+            properties: normalizedProperties,
+        });
+        return this;
+    }
+    merge(other) {
+        for (const [currencyId, delta] of other.currencyChanges.entries()) {
+            this.currencyChange(currencyId, delta);
+        }
+        for (const [currencyId, props] of other.currencyPropertyUpdates.entries()) {
+            this.currencyPropertyUpdates.set(currencyId, [...props]);
+        }
+        for (const item of other.newItemRequests) {
+            this.newItemRequests.push({ ...item });
+        }
+        for (const item of other.deleteItemRequests) {
+            this.deleteItemRequests.push({ ...item });
+        }
+        for (const item of other.updateItemRequests) {
+            this.updateItemRequests.push({
+                contentId: item.contentId,
+                id: this.toIdentifier(item.id),
+                properties: [...item.properties],
+            });
+        }
+        if (other.applyVipBonusFlag !== undefined) {
+            this.applyVipBonusFlag = other.applyVipBonusFlag;
+        }
+        return this;
+    }
+    isEmpty() {
+        return (this.currencyChanges.size === 0 &&
+            this.currencyPropertyUpdates.size === 0 &&
+            this.newItemRequests.length === 0 &&
+            this.deleteItemRequests.length === 0 &&
+            this.updateItemRequests.length === 0 &&
+            this.applyVipBonusFlag === undefined);
+    }
+    toRequest(options = {}) {
+        const payload = {};
+        if (options.transaction) {
+            payload.transaction = options.transaction;
+        }
+        if (this.applyVipBonusFlag !== undefined) {
+            payload.applyVipBonus = this.applyVipBonusFlag;
+        }
+        if (this.currencyChanges.size > 0) {
+            const currencies = {};
+            for (const [currencyId, delta] of this.currencyChanges.entries()) {
+                currencies[currencyId] = delta.toString();
+            }
+            payload.currencies = currencies;
+        }
+        if (this.currencyPropertyUpdates.size > 0) {
+            const currencyProperties = {};
+            for (const [currencyId, properties] of this.currencyPropertyUpdates.entries()) {
+                currencyProperties[currencyId] = properties.map((property) => ({ ...property }));
+            }
+            payload.currencyProperties = currencyProperties;
+        }
+        if (this.newItemRequests.length > 0) {
+            payload.newItems = this.newItemRequests.map((item) => ({
+                contentId: item.contentId,
+                properties: item.properties.map((property) => ({ ...property })),
+                reqId: item.reqId,
+            }));
+        }
+        if (this.deleteItemRequests.length > 0) {
+            payload.deleteItems = this.deleteItemRequests.map((item) => ({
+                contentId: item.contentId,
+                id: this.toIdentifier(item.id),
+            }));
+        }
+        if (this.updateItemRequests.length > 0) {
+            payload.updateItems = this.updateItemRequests.map((item) => ({
+                contentId: item.contentId,
+                id: this.toIdentifier(item.id),
+                properties: item.properties.map((property) => ({ ...property })),
+            }));
+        }
+        return payload;
+    }
+    normalizeId(value, kind) {
+        const trimmed = value.trim();
+        if (!trimmed) {
+            throw new Error(`Invalid ${kind} identifier: "${value}"`);
+        }
+        return trimmed;
+    }
+    toIdentifier(value) {
+        if (typeof value === 'bigint') {
+            return value.toString();
+        }
+        if (typeof value === 'number') {
+            if (!Number.isFinite(value)) {
+                throw new Error(`Invalid numeric identifier: ${value}`);
+            }
+            return Math.trunc(value).toString();
+        }
+        const trimmed = value.trim();
+        if (!trimmed) {
+            throw new Error('Identifier cannot be empty.');
+        }
+        return trimmed;
+    }
+}
+exports.InventoryUpdateBuilder = InventoryUpdateBuilder;
+class InventoryService {
+    constructor(dependencies) {
+        this.api = dependencies.api;
+        this.logger = dependencies.logger.child({ component: 'InventoryService' });
+        this.userId = dependencies.userId;
+        this.ensureScopes = dependencies.scopeChecker;
+    }
+    createBuilder() {
+        return new InventoryUpdateBuilder();
+    }
+    async update(builderOrCallback, options = {}) {
+        const builder = builderOrCallback instanceof InventoryUpdateBuilder ? builderOrCallback : this.createBuilder();
+        if (!(builderOrCallback instanceof InventoryUpdateBuilder)) {
+            await builderOrCallback(builder);
+        }
+        if (builder.isEmpty()) {
+            this.logger.debug('Inventory update skipped because builder produced no changes.');
+            return;
+        }
+        this.ensureScopes(['server']);
+        const payload = builder.toRequest(options);
+        await this.invokeInventoryPut(payload);
+    }
+    async setCurrencies(currencyValues, transaction) {
+        var _a;
+        this.ensureScopes(['server']);
+        const current = await this.getCurrencies(Object.keys(currencyValues));
+        const deltas = {};
+        for (const [currencyId, target] of Object.entries(currencyValues)) {
+            const currentVal = (_a = current[currencyId]) !== null && _a !== void 0 ? _a : BigInt(0);
+            const targetValue = BigInt(target);
+            const delta = targetValue - currentVal;
+            if (delta !== BigInt(0)) {
+                deltas[currencyId] = delta;
+            }
+        }
+        if (Object.keys(deltas).length === 0) {
+            this.logger.debug('No currency adjustments required; request skipped.');
+            return;
+        }
+        await this.update((builder) => {
+            for (const [currencyId, delta] of Object.entries(deltas)) {
+                builder.currencyChange(currencyId, delta);
+            }
+        }, { transaction });
+    }
+    async addCurrencies(currencyDeltas, transaction) {
+        await this.update((builder) => {
+            for (const [currencyId, delta] of Object.entries(currencyDeltas)) {
+                builder.currencyChange(currencyId, delta);
+            }
+        }, { transaction });
+    }
+    async addItem(contentId, properties = {}, transaction) {
+        await this.update((builder) => {
+            builder.addItem(contentId, properties);
+        }, { transaction });
+    }
+    async deleteItem(contentId, itemId, transaction) {
+        await this.update((builder) => {
+            builder.deleteItem(contentId, itemId);
+        }, { transaction });
+    }
+    async updateItem(contentId, itemId, properties, transaction) {
+        await this.update((builder) => {
+            builder.updateItem(contentId, itemId, properties);
+        }, { transaction });
+    }
+    async setCurrencyProperties(currencyId, properties, transaction) {
+        await this.update((builder) => {
+            builder.setCurrencyProperties(currencyId, properties);
+        }, { transaction });
+    }
+    async previewCurrencyGain(currencyChanges) {
+        this.ensureScopes(['server']);
+        const payload = {
+            currencies: Object.fromEntries(Object.entries(currencyChanges).map(([currencyId, amount]) => [currencyId, BigInt(amount).toString()])),
+        };
+        const response = await this.invokePreview(payload);
+        return response;
+    }
+    async getMultipliers() {
+        this.ensureScopes(['server']);
+        const response = await this.invokeGetMultipliers();
+        return response;
+    }
+    async getInventory(scope) {
+        this.ensureScopes(['server']);
+        const response = await this.invokeGetInventory(scope);
+        return response;
+    }
+    async getCurrencies(currencyIds) {
+        var _a;
+        const scope = Array.isArray(currencyIds) && currencyIds.length > 0 ? currencyIds.join(',') : 'currency';
+        const view = await this.getInventory(scope);
+        const result = {};
+        for (const currency of (_a = view.currencies) !== null && _a !== void 0 ? _a : []) {
+            result[currency.id] = BigInt(currency.amount);
+        }
+        return result;
+    }
+    async sendCurrency(request) {
+        var _a, _b, _c;
+        this.ensureScopes(['server']);
+        const payload = {
+            recipientPlayer: this.toIdentifier(request.recipientPlayer),
+            currencies: Object.fromEntries(Object.entries((_a = request.currencies) !== null && _a !== void 0 ? _a : {}).map(([currencyId, amount]) => [currencyId, BigInt(amount).toString()])),
+            transaction: request.transaction,
+        };
+        const response = (_c = (_b = this.api).inventoryPutTransferByObjectId) === null || _c === void 0 ? void 0 : _c.call(_b, this.userId, payload);
+        if (!response || typeof response.then !== 'function') {
+            throw new Error('inventoryPutTransferByObjectId API is unavailable in the current SDK.');
+        }
+        await response;
+    }
+    async invokeInventoryPut(payload) {
+        var _a, _b;
+        const response = (_b = (_a = this.api).inventoryPutByObjectId) === null || _b === void 0 ? void 0 : _b.call(_a, this.userId, payload);
+        if (!response || typeof response.then !== 'function') {
+            throw new Error('inventoryPutByObjectId API is unavailable in the current SDK.');
+        }
+        await response;
+    }
+    async invokePreview(payload) {
+        var _a, _b;
+        const response = (_b = (_a = this.api).inventoryPutPreviewByObjectId) === null || _b === void 0 ? void 0 : _b.call(_a, this.userId, payload);
+        if (!response || typeof response.then !== 'function') {
+            throw new Error('inventoryPutPreviewByObjectId API is unavailable in the current SDK.');
+        }
+        const result = await response;
+        if (!result || typeof result !== 'object' || !('body' in result)) {
+            return result;
+        }
+        return result.body;
+    }
+    async invokeGetMultipliers() {
+        var _a, _b;
+        const response = (_b = (_a = this.api).inventoryGetMultipliersByObjectId) === null || _b === void 0 ? void 0 : _b.call(_a, this.userId);
+        if (!response || typeof response.then !== 'function') {
+            throw new Error('inventoryGetMultipliersByObjectId API is unavailable in the current SDK.');
+        }
+        const result = await response;
+        if (!result || typeof result !== 'object' || !('body' in result)) {
+            return result;
+        }
+        return result.body;
+    }
+    async invokeGetInventory(scope) {
+        var _a, _b;
+        const response = (_b = (_a = this.api).inventoryGetByObjectId) === null || _b === void 0 ? void 0 : _b.call(_a, this.userId, scope);
+        if (!response || typeof response.then !== 'function') {
+            throw new Error('inventoryGetByObjectId API is unavailable in the current SDK.');
+        }
+        const result = await response;
+        if (!result || typeof result !== 'object' || !('body' in result)) {
+            return result;
+        }
+        return result.body;
+    }
+    toIdentifier(value) {
+        if (typeof value === 'string') {
+            const trimmed = value.trim();
+            if (!trimmed) {
+                throw new Error('Identifier cannot be empty.');
+            }
+            return trimmed;
+        }
+        if (typeof value === 'number') {
+            if (!Number.isFinite(value)) {
+                throw new Error(`Invalid numeric identifier: ${value}`);
+            }
+            return Math.trunc(value).toString();
+        }
+        return value.toString();
+    }
+}
+exports.InventoryService = InventoryService;
+function createInventoryService(api, logger, userId, hasScopes) {
+    return new InventoryService({
+        api,
+        logger,
+        userId,
+        scopeChecker: (requiredScopes) => {
+            if (!hasScopes(requiredScopes)) {
+                throw new errors_js_1.MissingScopesError(requiredScopes);
+            }
+        },
+    });
+}