@opra/core 0.21.0 → 0.23.0

package/cjs/adapter/http/request-handlers/entity-request-handler.js

@@ -0,0 +1,378 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityRequestHandler = void 0;
+const tslib_1 = require("tslib");
+const body_parser_1 = tslib_1.__importDefault(require("body-parser"));
+const putil_varhelpers_1 = require("putil-varhelpers");
+const common_1 = require("@opra/common");
+const operation_context_js_1 = require("../../operation-context.js");
+const request_host_js_1 = require("../../request.host.js");
+const response_host_js_1 = require("../../response.host.js");
+const query_parsers_js_1 = require("../helpers/query-parsers.js");
+const request_handler_base_js_1 = require("./request-handler-base.js");
+/**
+ * @class EntityRequestHandler
+ */
+class EntityRequestHandler extends request_handler_base_js_1.RequestHandlerBase {
+    constructor(adapter) {
+        super(adapter);
+        this.adapter = adapter;
+        this.bodyLoaders = new WeakMap();
+    }
+    async processRequest(executionContext) {
+        const { incoming, outgoing } = executionContext.switchToHttp();
+        // Parse incoming message and create Request object
+        const request = await this.parseRequest(incoming);
+        if (!request)
+            return;
+        const response = new response_host_js_1.ResponseHost({ http: outgoing });
+        const context = operation_context_js_1.OperationContext.from(executionContext, request, response);
+        // Execute operation
+        await this.executeOperation(context);
+        if (response.errors.length) {
+            context.errors.push(...response.errors);
+            return;
+        }
+        await this.sendResponse(context);
+    }
+    async parseRequest(incoming) {
+        const p = incoming.parsedUrl.path[0];
+        const resource = this.adapter.api.getResource(p.resource);
+        try {
+            if (resource instanceof common_1.Collection)
+                return await this.parseCollectionRequest(resource, incoming);
+            if (resource instanceof common_1.Singleton)
+                return await this.parseSingletonRequest(resource, incoming);
+        }
+        catch (e) {
+            if (e instanceof common_1.OpraException)
+                throw e;
+            throw new common_1.BadRequestError(e);
+        }
+    }
+    async executeOperation(context) {
+        const request = context.request;
+        const { response } = context;
+        const resource = request.resource;
+        // Call operation handler method
+        let value;
+        try {
+            value = await request.controller[request.operation].call(request.controller, context);
+            if (value == null)
+                value = response.value;
+            const { operation } = request;
+            if (operation === 'delete' || operation === 'deleteMany' || operation === 'updateMany') {
+                let affected = 0;
+                if (typeof value === 'number')
+                    affected = value;
+                if (typeof value === 'boolean')
+                    affected = value ? 1 : 0;
+                if (typeof value === 'object')
+                    affected = value.affected || value.affectedRows ||
+                        (operation === 'updateMany' ? value.updated : value.deleted);
+                response.value = affected;
+            }
+            else {
+                // "get" and "update" operations must return the entity instance, otherwise it means resource not found
+                if (value == null && (request.operation === 'get' || request.operation === 'update'))
+                    throw new common_1.ResourceNotFoundError(resource.name, request.key);
+                // "findMany" operation should return array of entity instances
+                if (request.operation === 'findMany')
+                    value = value == null ? [] : Array.isArray(value) ? value : [value];
+                else
+                    value = value == null ? {} : Array.isArray(value) ? value[0] : value;
+                response.value = value;
+            }
+        }
+        catch (error) {
+            response.errors.push(error);
+        }
+    }
+    async sendResponse(context) {
+        const { request, response } = context;
+        const resource = request.resource;
+        const outgoing = response.switchToHttp();
+        let responseObject;
+        if (request.operation === 'delete' || request.operation === 'deleteMany' || request.operation === 'updateMany') {
+            responseObject = {
+                resource: resource.name,
+                operation: request.operation,
+                affected: response.value
+            };
+        }
+        else {
+            if (!response.value)
+                throw new common_1.InternalServerError(`"${request.operation}" operation should return value`);
+            const encode = resource.getEncoder(request.operation);
+            const data = encode(response.value, { coerce: true });
+            if (request.operation === 'create')
+                outgoing.statusCode = 201;
+            responseObject = {
+                resource: resource.name,
+                operation: request.operation,
+                data
+            };
+            if (request.operation === 'create' || request.operation === 'update')
+                responseObject.affected = 1;
+            if (request.operation === 'findMany' && response.count != null && response.count >= 0)
+                responseObject.totalCount = response.count;
+        }
+        outgoing.statusCode = outgoing.statusCode || common_1.HttpStatusCodes.OK;
+        const body = this.adapter._i18n.deep(responseObject);
+        outgoing.setHeader(common_1.HttpHeaderCodes.Content_Type, 'application/json; charset=utf-8');
+        outgoing.send(JSON.stringify(body));
+        outgoing.end();
+    }
+    async parseCollectionRequest(resource, incoming) {
+        if ((incoming.method === 'POST' || incoming.method === 'PATCH') &&
+            incoming.headers['content-type'] !== 'application/json')
+            throw new common_1.BadRequestError({ message: 'Unsupported Content-Type' });
+        const contentId = incoming.headers['content-id'];
+        const p = incoming.parsedUrl.path[0];
+        const params = incoming.parsedUrl.searchParams;
+        switch (incoming.method) {
+            case 'POST': {
+                if (p.key == null) {
+                    const operationMeta = await this.assertOperation(resource, 'create');
+                    const jsonReader = this.getBodyLoader(operationMeta);
+                    const decode = resource.getDecoder('create');
+                    const data = decode(await jsonReader(incoming), { coerce: true });
+                    const pick = (0, query_parsers_js_1.parseArrayParam)(params.get('$pick'));
+                    const omit = (0, query_parsers_js_1.parseArrayParam)(params.get('$omit'));
+                    const include = (0, query_parsers_js_1.parseArrayParam)(params.get('$include'));
+                    return new request_host_js_1.RequestHost({
+                        controller: operationMeta.controller,
+                        http: incoming,
+                        contentId,
+                        resource,
+                        operation: 'create',
+                        data,
+                        params: {
+                            pick: pick && resource.normalizeFieldPath(pick),
+                            omit: omit && resource.normalizeFieldPath(omit),
+                            include: include && resource.normalizeFieldPath(include)
+                        }
+                    });
+                }
+                break;
+            }
+            case 'DELETE': {
+                if (p.key != null) {
+                    const operationMeta = await this.assertOperation(resource, 'delete');
+                    return new request_host_js_1.RequestHost({
+                        controller: operationMeta.controller,
+                        http: incoming,
+                        contentId,
+                        resource,
+                        operation: 'delete',
+                        key: resource.parseKeyValue(p.key)
+                    });
+                }
+                const operationMeta = await this.assertOperation(resource, 'deleteMany');
+                const filter = resource.normalizeFilter(params.get('$filter'));
+                return new request_host_js_1.RequestHost({
+                    controller: operationMeta.controller,
+                    http: incoming,
+                    contentId,
+                    resource,
+                    operation: 'deleteMany',
+                    params: {
+                        filter
+                    }
+                });
+            }
+            case 'GET': {
+                const pick = (0, query_parsers_js_1.parseArrayParam)(params.get('$pick'));
+                const omit = (0, query_parsers_js_1.parseArrayParam)(params.get('$omit'));
+                const include = (0, query_parsers_js_1.parseArrayParam)(params.get('$include'));
+                if (p.key != null) {
+                    const operationMeta = await this.assertOperation(resource, 'get');
+                    return new request_host_js_1.RequestHost({
+                        controller: operationMeta.controller,
+                        http: incoming,
+                        contentId,
+                        resource,
+                        operation: 'get',
+                        key: resource.parseKeyValue(p.key),
+                        params: {
+                            pick: pick && resource.normalizeFieldPath(pick),
+                            omit: omit && resource.normalizeFieldPath(omit),
+                            include: include && resource.normalizeFieldPath(include)
+                        }
+                    });
+                }
+                const operationMeta = await this.assertOperation(resource, 'findMany');
+                const filter = resource.normalizeFilter(params.get('$filter'));
+                const sort = (0, query_parsers_js_1.parseArrayParam)(params.get('$sort'));
+                return new request_host_js_1.RequestHost({
+                    controller: operationMeta.controller,
+                    http: incoming,
+                    contentId,
+                    resource,
+                    operation: 'findMany',
+                    params: {
+                        pick: pick && resource.normalizeFieldPath(pick),
+                        omit: omit && resource.normalizeFieldPath(omit),
+                        include: include && resource.normalizeFieldPath(include),
+                        sort: sort && resource.normalizeSortFields(sort),
+                        filter,
+                        limit: (0, putil_varhelpers_1.toInt)(params.get('$limit')),
+                        skip: (0, putil_varhelpers_1.toInt)(params.get('$skip')),
+                        distinct: (0, putil_varhelpers_1.toBoolean)(params.get('$distinct')),
+                        count: (0, putil_varhelpers_1.toBoolean)(params.get('$count')),
+                    }
+                });
+            }
+            case 'PATCH': {
+                if (p.key != null) {
+                    const operationMeta = await this.assertOperation(resource, 'update');
+                    const jsonReader = this.getBodyLoader(operationMeta);
+                    const decode = resource.getDecoder('update');
+                    const data = decode(await jsonReader(incoming), { coerce: true });
+                    const pick = (0, query_parsers_js_1.parseArrayParam)(params.get('$pick'));
+                    const omit = (0, query_parsers_js_1.parseArrayParam)(params.get('$omit'));
+                    const include = (0, query_parsers_js_1.parseArrayParam)(params.get('$include'));
+                    return new request_host_js_1.RequestHost({
+                        controller: operationMeta.controller,
+                        http: incoming,
+                        contentId,
+                        resource,
+                        operation: 'update',
+                        key: resource.parseKeyValue(p.key),
+                        data,
+                        params: {
+                            pick: pick && resource.normalizeFieldPath(pick),
+                            omit: omit && resource.normalizeFieldPath(omit),
+                            include: include && resource.normalizeFieldPath(include),
+                        }
+                    });
+                }
+                const operationMeta = await this.assertOperation(resource, 'updateMany');
+                const jsonReader = this.getBodyLoader(operationMeta);
+                const decode = resource.getDecoder('updateMany');
+                const data = decode(await jsonReader(incoming), { coerce: true });
+                const filter = resource.normalizeFilter(params.get('$filter'));
+                return new request_host_js_1.RequestHost({
+                    controller: operationMeta.controller,
+                    http: incoming,
+                    contentId,
+                    resource,
+                    operation: 'updateMany',
+                    data,
+                    params: {
+                        filter,
+                    }
+                });
+            }
+        }
+        throw new common_1.MethodNotAllowedError({
+            message: `Collection resources do not accept http "${incoming.method}" method`
+        });
+    }
+    async parseSingletonRequest(resource, incoming) {
+        if ((incoming.method === 'POST' || incoming.method === 'PATCH') &&
+            incoming.headers['content-type'] !== 'application/json')
+            throw new common_1.BadRequestError({ message: 'Unsupported Content-Type' });
+        const contentId = incoming.headers['content-id'];
+        const params = incoming.parsedUrl.searchParams;
+        switch (incoming.method) {
+            case 'POST': {
+                const operationMeta = await this.assertOperation(resource, 'create');
+                const jsonReader = this.getBodyLoader(operationMeta);
+                const decode = resource.getDecoder('create');
+                const data = decode(await jsonReader(incoming), { coerce: true });
+                const pick = (0, query_parsers_js_1.parseArrayParam)(params.get('$pick'));
+                const omit = (0, query_parsers_js_1.parseArrayParam)(params.get('$omit'));
+                const include = (0, query_parsers_js_1.parseArrayParam)(params.get('$include'));
+                return new request_host_js_1.RequestHost({
+                    controller: operationMeta.controller,
+                    http: incoming,
+                    contentId,
+                    resource,
+                    operation: 'create',
+                    data,
+                    params: {
+                        pick: pick && resource.normalizeFieldPath(pick),
+                        omit: omit && resource.normalizeFieldPath(omit),
+                        include: include && resource.normalizeFieldPath(include)
+                    }
+                });
+            }
+            case 'DELETE': {
+                const operationMeta = await this.assertOperation(resource, 'delete');
+                return new request_host_js_1.RequestHost({
+                    controller: operationMeta.controller,
+                    http: incoming,
+                    contentId,
+                    resource,
+                    operation: 'delete',
+                });
+            }
+            case 'GET': {
+                const operationMeta = await this.assertOperation(resource, 'get');
+                const pick = (0, query_parsers_js_1.parseArrayParam)(params.get('$pick'));
+                const omit = (0, query_parsers_js_1.parseArrayParam)(params.get('$omit'));
+                const include = (0, query_parsers_js_1.parseArrayParam)(params.get('$include'));
+                return new request_host_js_1.RequestHost({
+                    controller: operationMeta.controller,
+                    http: incoming,
+                    contentId,
+                    resource,
+                    operation: 'get',
+                    params: {
+                        pick: pick && resource.normalizeFieldPath(pick),
+                        omit: omit && resource.normalizeFieldPath(omit),
+                        include: include && resource.normalizeFieldPath(include)
+                    }
+                });
+            }
+            case 'PATCH': {
+                const operationMeta = await this.assertOperation(resource, 'update');
+                const jsonReader = this.getBodyLoader(operationMeta);
+                const decode = resource.getDecoder('update');
+                const data = decode(await jsonReader(incoming), { coerce: true });
+                const pick = (0, query_parsers_js_1.parseArrayParam)(params.get('$pick'));
+                const omit = (0, query_parsers_js_1.parseArrayParam)(params.get('$omit'));
+                const include = (0, query_parsers_js_1.parseArrayParam)(params.get('$include'));
+                return new request_host_js_1.RequestHost({
+                    controller: operationMeta.controller,
+                    http: incoming,
+                    contentId,
+                    resource,
+                    operation: 'update',
+                    data,
+                    params: {
+                        pick: pick && resource.normalizeFieldPath(pick),
+                        omit: omit && resource.normalizeFieldPath(omit),
+                        include: include && resource.normalizeFieldPath(include),
+                    }
+                });
+            }
+        }
+        throw new common_1.MethodNotAllowedError({
+            message: `Singleton resources do not accept http "${incoming.method}" method`
+        });
+    }
+    getBodyLoader(operation) {
+        let bodyLoader = this.bodyLoaders.get(operation);
+        if (!bodyLoader) {
+            const parser = body_parser_1.default.json({
+                limit: operation.input?.maxContentSize,
+                type: 'json'
+            });
+            bodyLoader = (incoming) => {
+                return new Promise((resolve, reject) => {
+                    const next = (error) => {
+                        if (error)
+                            return reject(error);
+                        resolve(incoming.body);
+                    };
+                    parser(incoming, {}, next);
+                });
+            };
+            this.bodyLoaders.set(operation, bodyLoader);
+        }
+        return bodyLoader;
+    }
+}
+exports.EntityRequestHandler = EntityRequestHandler;

package/cjs/adapter/http/request-handlers/request-handler-base.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestHandlerBase = void 0;
+const common_1 = require("@opra/common");
+/**
+ * @class RequestHandlerBase
+ */
+class RequestHandlerBase {
+    constructor(adapter) {
+        this.adapter = adapter;
+    }
+    async assertOperation(resource, operation) {
+        const controller = await this.adapter.getController(resource);
+        const operationMeta = (typeof controller?.[operation] === 'function') && resource.operations[operation];
+        if (operationMeta)
+            return {
+                ...operationMeta,
+                controller
+            };
+        throw new common_1.ForbiddenError({
+            message: (0, common_1.translate)('RESOLVER_FORBIDDEN', { resource: resource.name, operation }, `'{{resource}}' endpoint does not accept '{{operation}}' operations`),
+            severity: 'error',
+            code: 'RESOLVER_FORBIDDEN'
+        });
+    }
+}
+exports.RequestHandlerBase = RequestHandlerBase;

package/cjs/adapter/http/request-handlers/storage-request-handler.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StorageRequestHandler = void 0;
+const tslib_1 = require("tslib");
+const promises_1 = tslib_1.__importDefault(require("fs/promises"));
+const os_1 = tslib_1.__importDefault(require("os"));
+const common_1 = require("@opra/common");
+const operation_context_js_1 = require("../../operation-context.js");
+const request_host_js_1 = require("../../request.host.js");
+const response_host_js_1 = require("../../response.host.js");
+const multipart_helper_js_1 = require("../helpers/multipart-helper.js");
+const request_handler_base_js_1 = require("./request-handler-base.js");
+/**
+ * @class StorageRequestHandler
+ */
+class StorageRequestHandler extends request_handler_base_js_1.RequestHandlerBase {
+    constructor(adapter, options) {
+        super(adapter);
+        this.adapter = adapter;
+        this._uploadDir = options?.uploadDir || os_1.default.tmpdir();
+    }
+    async processRequest(executionContext) {
+        const { incoming, outgoing } = executionContext.switchToHttp();
+        // Parse incoming message and create Request object
+        const request = await this.parseRequest(executionContext, incoming);
+        if (!request)
+            return;
+        const response = new response_host_js_1.ResponseHost({ http: outgoing });
+        const context = operation_context_js_1.OperationContext.from(executionContext, request, response);
+        // Execute operation
+        await this.executeOperation(context);
+        if (response.errors.length) {
+            context.errors.push(...response.errors);
+            return;
+        }
+        await this.sendResponse(context);
+    }
+    async parseRequest(executionContext, incoming) {
+        const contentId = incoming.headers['content-id'];
+        const p = incoming.parsedUrl.path[0];
+        const resource = this.adapter.api.getResource(p.resource);
+        try {
+            if (!(resource instanceof common_1.Storage))
+                return;
+            switch (incoming.method) {
+                case 'GET': {
+                    const operationMeta = await this.assertOperation(resource, 'get');
+                    return new request_host_js_1.RequestHost({
+                        controller: operationMeta.controller,
+                        http: incoming,
+                        resource,
+                        operation: 'get',
+                        contentId
+                    });
+                }
+                case 'DELETE': {
+                    const operationMeta = await this.assertOperation(resource, 'delete');
+                    return new request_host_js_1.RequestHost({
+                        controller: operationMeta.controller,
+                        http: incoming,
+                        resource,
+                        operation: 'delete',
+                        contentId
+                    });
+                }
+                case 'POST': {
+                    const operationMeta = await this.assertOperation(resource, 'post');
+                    await promises_1.default.mkdir(this._uploadDir, { recursive: true });
+                    const multipartIterator = new multipart_helper_js_1.MultipartIterator(incoming, {
+                        ...operationMeta,
+                        filename: () => this.adapter.serviceName + '_p' + process.pid +
+                            't' + String(Date.now()).substring(8) + 'r' + (0, common_1.uid)(12)
+                    });
+                    multipartIterator.pause();
+                    // Add an hook to clean up files after request finished
+                    executionContext.on('finish', async () => {
+                        multipartIterator.cancel();
+                        await multipartIterator.deleteFiles().catch(() => void 0);
+                    });
+                    return new request_host_js_1.RequestHost({
+                        controller: operationMeta.controller,
+                        http: incoming,
+                        resource,
+                        operation: 'post',
+                        contentId,
+                        parts: multipartIterator
+                    });
+                }
+            }
+        }
+        catch (e) {
+            if (e instanceof common_1.OpraException)
+                throw e;
+            throw new common_1.BadRequestError(e);
+        }
+    }
+    async executeOperation(context) {
+        const request = context.request;
+        const { response } = context;
+        // Call operation handler method
+        let value;
+        try {
+            value = await request.controller[request.operation].call(request.controller, context);
+            if (response.value == null)
+                response.value = value;
+        }
+        catch (error) {
+            response.errors.push(error);
+        }
+    }
+    async sendResponse(context) {
+        const { response } = context;
+        const outgoing = response.switchToHttp();
+        outgoing.statusCode = outgoing.statusCode || common_1.HttpStatusCodes.OK;
+        if (response.value != null) {
+            if (typeof response.value === 'string') {
+                if (!outgoing.hasHeader('content-type'))
+                    outgoing.setHeader('content-type', 'text/plain');
+                outgoing.send(response.value);
+            }
+            else if (Buffer.isBuffer(response.value) || (0, common_1.isReadable)(response.value)) {
+                if (!outgoing.hasHeader('content-type'))
+                    outgoing.setHeader('content-type', 'application/octet-stream');
+                outgoing.send(response.value);
+            }
+            else {
+                outgoing.setHeader('content-type', 'application/json; charset=utf-8');
+                outgoing.send(JSON.stringify(response.value));
+            }
+        }
+        outgoing.end();
+    }
+}
+exports.StorageRequestHandler = StorageRequestHandler;

package/cjs/adapter/operation-context.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperationContext = void 0;
+var OperationContext;
+(function (OperationContext) {
+    function from(executionContext, request, response) {
+        const out = {
+            request,
+            response,
+            requestScope: {}
+        };
+        Object.setPrototypeOf(out, executionContext);
+        return out;
+    }
+    OperationContext.from = from;
+})(OperationContext || (exports.OperationContext = OperationContext = {}));

package/cjs/adapter/platform-adapter.host.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlatformAdapterHost = void 0;
+const tslib_1 = require("tslib");
+const path_1 = tslib_1.__importDefault(require("path"));
+const putil_varhelpers_1 = require("putil-varhelpers");
+const strict_typed_events_1 = require("strict-typed-events");
+const common_1 = require("@opra/common");
+const logger_js_1 = require("./services/logger.js");
+/**
+ * @class PlatformAdapterHost
+ */
+class PlatformAdapterHost extends strict_typed_events_1.AsyncEventEmitter {
+    constructor(api, options) {
+        super();
+        this.api = api;
+        this._controllers = new WeakMap();
+        this._initialized = false;
+        this._options = options || {};
+        this._logger = options?.logger && options.logger instanceof logger_js_1.Logger
+            ? options.logger
+            : new logger_js_1.Logger({ instance: options?.logger });
+        // Assign events
+        if (options?.on) {
+            for (const [event, fn] of Object.entries(options.on)) {
+                /* istanbul ignore next */
+                if (typeof fn === 'function')
+                    this.on(event, fn);
+            }
+        }
+        // Make a safe service name
+        this._serviceName = (0, putil_varhelpers_1.pascalCase)((api.info.title || '').replace(/[^a-z0-9_ ]/ig, '')) || 'OpraService';
+        if (!/^[a-z]/i.test(this._serviceName))
+            this._serviceName = 'X' + this._serviceName;
+    }
+    get platform() {
+        return this._platform;
+    }
+    get protocol() {
+        return this._protocol;
+    }
+    get serviceName() {
+        return this.api.info.title;
+    }
+    async close() {
+        const promises = [];
+        for (const r of this.api.resources.values()) {
+            const onShutdown = r.onShutdown;
+            if (onShutdown)
+                promises.push((async () => onShutdown.call(r.controller, r))());
+        }
+        await Promise.allSettled(promises);
+    }
+    /**
+     * Initializes the adapter
+     */
+    async init() {
+        if (this._initialized)
+            return;
+        // Init I18n
+        if (this._options?.i18n instanceof common_1.I18n)
+            this._i18n = this._options.i18n;
+        else if (typeof this._options?.i18n === 'function')
+            this._i18n = await this._options.i18n();
+        else
+            this._i18n = await this._createI18n(this._options?.i18n);
+        this._i18n = this._i18n || common_1.I18n.defaultInstance;
+        if (!this._i18n.isInitialized)
+            await this._i18n.init();
+        // Initialize all controllers
+        for (const resource of this.api.resources.values()) {
+            await this.getController(resource);
+        }
+        this._initialized = true;
+    }
+    async getController(resource) {
+        resource = typeof resource === 'object' && resource instanceof common_1.Resource
+            ? resource : this.api.getResource(resource);
+        let controller = this._controllers.get(resource);
+        if (!controller) {
+            if (resource.controller) {
+                controller = typeof resource.controller === 'function' ?
+                    new resource.controller()
+                    : resource.controller;
+                // Initialize controller
+                if (typeof controller.onInit === 'function')
+                    await controller.onInit.call(controller);
+                this._controllers.set(resource, controller);
+            }
+        }
+        return controller;
+    }
+    async _createI18n(options) {
+        const opts = {
+            ...options,
+        };
+        delete opts.resourceDirs;
+        const instance = common_1.I18n.createInstance(opts);
+        await instance.init();
+        await instance.loadResourceDir(path_1.default.resolve((0, common_1.getStackFileName)(), '../../../i18n'));
+        if (options?.resourceDirs)
+            for (const dir of options.resourceDirs)
+                await instance.loadResourceDir(dir);
+        return instance;
+    }
+}
+exports.PlatformAdapterHost = PlatformAdapterHost;

package/cjs/adapter/request.host.js

@@ -3,9 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RequestHost = void 0;
 class RequestHost {
     constructor(init) {
-        this.contentId = '';
         Object.assign(this, init);
-        this.resourceKind = this.resource.kind;
+        this.params = this.params || {};
     }
     switchToHttp() {
         if (this.http)

package/cjs/adapter/request.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });