@opra/core 0.0.12 → 0.1.0

package/cjs/enums/http-headers.enum.js

@@ -8,7 +8,8 @@ exports.HttpHeaders = void 0;
 var HttpHeaders;
 (function (HttpHeaders) {
     /* *** Custom Headers *** */
-    HttpHeaders["X_Opra_Version"] = "X-Opra-Version";
+    HttpHeaders["X_Opra_Version"] = "X-OPRA-Version";
+    HttpHeaders["X_Opra_Schema"] = "X-OPRA-Schema";
     /* *** Authentication *** */
     /**
      * Defines the authentication method that should be used to access a resource.

package/cjs/exception/http-errors/not-acceptable.error.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotAcceptableError = void 0;
+const i18n_1 = require("@opra/i18n");
+const index_js_1 = require("../../enums/index.js");
+const api_exception_js_1 = require("../api-exception.js");
+/**
+ * 406 Not Acceptable
+ * This response is sent when the web server, after performing server-driven content negotiation,
+ * doesn't find any content that conforms to the criteria given by the user agent.
+ */
+class NotAcceptableError extends api_exception_js_1.ApiException {
+    constructor(response, cause) {
+        super(response, cause);
+        this.status = index_js_1.HttpStatus.NOT_ACCEPTABLE;
+    }
+    _initResponse(response) {
+        super._initResponse({
+            message: (0, i18n_1.translate)('error:NOT_ACCEPTABLE', 'Not Acceptable'),
+            severity: 'error',
+            code: 'NOT_ACCEPTABLE',
+            ...response
+        });
+    }
+}
+exports.NotAcceptableError = NotAcceptableError;

package/cjs/exception/index.js

@@ -7,7 +7,9 @@ tslib_1.__exportStar(require("./http-errors/failed-dependency.error.js"), export
 tslib_1.__exportStar(require("./http-errors/forbidden.error.js"), exports);
 tslib_1.__exportStar(require("./http-errors/internal-server.error.js"), exports);
 tslib_1.__exportStar(require("./http-errors/method-not-allowed.error.js"), exports);
+tslib_1.__exportStar(require("./http-errors/not-acceptable.error.js"), exports);
 tslib_1.__exportStar(require("./http-errors/not-found.error.js"), exports);
 tslib_1.__exportStar(require("./http-errors/unauthorized.error.js"), exports);
 tslib_1.__exportStar(require("./http-errors/unprocessable-entity.error.js"), exports);
 tslib_1.__exportStar(require("./resource-errors/resource-conflict.error.js"), exports);
+tslib_1.__exportStar(require("./resource-errors/resource-not-found.error.js"), exports);

package/cjs/exception/resource-errors/resource-not-found.error.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceNotFoundError = void 0;
+const i18n_1 = require("@opra/i18n");
+const index_js_1 = require("../../enums/index.js");
+const api_exception_js_1 = require("../api-exception.js");
+class ResourceNotFoundError extends api_exception_js_1.ApiException {
+    constructor(resource, keyValue, cause) {
+        super({
+            message: (0, i18n_1.translate)(`error:RESOURCE_NOT_FOUND`, { resource: resource + '@' + keyValue }),
+            severity: 'error',
+            code: 'RESOURCE_NOT_FOUND',
+            subject: resource,
+            key: keyValue
+        }, cause);
+        this.status = index_js_1.HttpStatus.NOT_FOUND;
+    }
+}
+exports.ResourceNotFoundError = ResourceNotFoundError;

package/cjs/implementation/adapter-utils/entity-resource-execute.util.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.entityResourceExecute = void 0;
+const i18n_1 = require("@opra/i18n");
+const schema_1 = require("@opra/schema");
+const index_js_1 = require("../../enums/index.js");
+const index_js_2 = require("../../exception/index.js");
+const query_interface_js_1 = require("../../interfaces/query.interface.js");
+async function entityResourceExecute(service, resource, context) {
+    const { query } = context;
+    if (query_interface_js_1.OpraQuery.isSearchQuery(query)) {
+        const promises = [];
+        let search;
+        let count;
+        promises.push(executeFn(service, resource, context, query.queryType)
+            .then(v => search = v));
+        if (query.count) {
+            promises.push(executeFn(service, resource, context, 'count')
+                .then(v => count = v));
+        }
+        await Promise.all(promises);
+        context.response.value = {
+            ...search,
+            ...count
+        };
+        return;
+    }
+    context.response.value = await executeFn(service, resource, context, query.queryType);
+}
+exports.entityResourceExecute = entityResourceExecute;
+async function executeFn(service, resource, context, queryType) {
+    const resolverInfo = resource.metadata.methods?.[queryType];
+    if (!resolverInfo.handler)
+        throw new index_js_2.ForbiddenError({
+            message: (0, i18n_1.translate)('RESOLVER_FORBIDDEN', { queryType }),
+            severity: 'error',
+            code: 'RESOLVER_FORBIDDEN'
+        });
+    let result = await resolverInfo.handler(context);
+    switch (queryType) {
+        case 'search':
+            context.response.headers.set(index_js_1.HttpHeaders.X_Opra_Schema, '/$schema/types/' + resource.dataType.name);
+            return {
+                items: Array.isArray(result) ? result : (context.response.value ? [result] : [])
+            };
+        case 'get':
+        case 'update':
+            if (!result) {
+                const query = context.query;
+                throw new index_js_2.ResourceNotFoundError(resource.name, query.keyValue);
+            }
+            break;
+        case 'count':
+            return { count: result || 0 };
+        case 'delete':
+        case 'deleteMany':
+        case 'updateMany':
+            let affectedRecords;
+            if (typeof result === 'number')
+                affectedRecords = result;
+            if (typeof result === 'boolean')
+                affectedRecords = result ? 1 : 0;
+            if (typeof result === 'object')
+                affectedRecords = result.affectedRows || result.affectedRecords;
+            return { affectedRecords };
+    }
+    if (!result)
+        return;
+    result = Array.isArray(result) ? result[0] : result;
+    let dataType = resource.dataType;
+    if (context.resultPath) {
+        const pathArray = context.resultPath.split('.');
+        for (const field of pathArray) {
+            const prop = dataType instanceof schema_1.ComplexType ? dataType.fields.get(field) : undefined;
+            dataType = prop && prop.type ? service.types.get(prop.type) : undefined;
+            result = result && typeof result === 'object' && result[field];
+        }
+    }
+    if (queryType === 'create')
+        context.response.status = 201;
+    if (dataType)
+        context.response.headers.set(index_js_1.HttpHeaders.X_Opra_Schema, '/$schema/types/' + dataType.name);
+    return result;
+}

package/cjs/implementation/adapter-utils/resource-execute.util.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resourceExecute = void 0;
+const schema_1 = require("@opra/schema");
+const entity_resource_execute_util_js_1 = require("./entity-resource-execute.util.js");
+async function resourceExecute(service, resource, context) {
+    if (resource instanceof schema_1.EntityResource)
+        return await (0, entity_resource_execute_util_js_1.entityResourceExecute)(service, resource, context);
+    throw new Error(`Executing "${resource.kind}" has not been implemented yet`);
+}
+exports.resourceExecute = resourceExecute;

package/cjs/implementation/adapter-utils/resource-prepare.util.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resourcePrepare = void 0;
+async function resourcePrepare(resource, context) {
+    const { query } = context;
+    const fn = resource.metadata['pre_' + query.queryType];
+    if (fn && typeof fn === 'function') {
+        await fn(context);
+    }
+}
+exports.resourcePrepare = resourcePrepare;

package/cjs/implementation/{adapter/adapter.js → adapter.js}

@@ -3,9 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpraAdapter = void 0;
 const strict_typed_events_1 = require("strict-typed-events");
 const i18n_1 = require("@opra/i18n");
-const index_js_1 = require("../../exception/index.js");
-const wrap_error_js_1 = require("../../exception/wrap-error.js");
-const create_i18n_js_1 = require("../../utils/create-i18n.js");
+const index_js_1 = require("../enums/index.js");
+const index_js_2 = require("../exception/index.js");
+const wrap_error_js_1 = require("../exception/wrap-error.js");
+const create_i18n_js_1 = require("../utils/create-i18n.js");
+const resource_execute_util_js_1 = require("./adapter-utils/resource-execute.util.js");
+const resource_prepare_util_js_1 = require("./adapter-utils/resource-prepare.util.js");
 class OpraAdapter {
     service;
     i18n;
@@ -37,20 +40,24 @@ class OpraAdapter {
                 // If previous request in bucket had an error and executed an update
                 // we do not execute next requests
                 if (stop) {
-                    context.response.errors.push(new index_js_1.FailedDependencyError());
+                    context.response.errors.push(new index_js_2.FailedDependencyError());
                     continue;
                 }
                 try {
-                    const resource = context.query.resource;
                     const promise = (async () => {
-                        await resource.prepare(context);
+                        if (context.query.queryType === 'schema') {
+                            await this._getSchemaExecute(context);
+                            return;
+                        }
+                        const resource = context.query.resource;
+                        await (0, resource_prepare_util_js_1.resourcePrepare)(resource, context);
                         if (this.userContextResolver && !userContext)
                             userContext = this.userContextResolver({
                                 executionContext,
                                 isBatch: this.isBatch(executionContext)
                             });
                         context.userContext = userContext;
-                        await resource.execute(context);
+                        await (0, resource_execute_util_js_1.resourceExecute)(this.service, resource, context);
                     })().catch(e => {
                         context.response.errors.push(e);
                     });
@@ -91,6 +98,32 @@ class OpraAdapter {
             }
         }
     }
+    async _getSchemaExecute(ctx) {
+        const query = ctx.query;
+        let out;
+        if (query.resourcePath.length > 2)
+            throw new index_js_2.BadRequestError();
+        if (query.resourcePath?.length) {
+            if (query.resourcePath[0] === 'resources') {
+                const resource = this.service.getResource(query.resourcePath[1]);
+                out = resource.getSchema(true);
+                query.resourcePath[1] = resource.name;
+                ctx.response.headers.set(index_js_1.HttpHeaders.X_Opra_Schema, 'http://www.oprajs.com/reference/v1/schema#' + resource.kind);
+            }
+            else if (query.resourcePath[0] === 'types') {
+                const dataType = this.service.getDataType(query.resourcePath[1]);
+                out = dataType.getSchema(true);
+                query.resourcePath[1] = dataType.name;
+                ctx.response.headers.set(index_js_1.HttpHeaders.X_Opra_Schema, 'http://www.oprajs.com/reference/v1/schema#' + dataType.kind);
+            }
+            else
+                throw new index_js_2.BadRequestError();
+            ctx.response.value = out;
+            return;
+        }
+        ctx.response.headers.set(index_js_1.HttpHeaders.X_Opra_Schema, 'http://www.oprajs.com/reference/v1/schema');
+        ctx.response.value = this.service.getSchema(true);
+    }
     static async initI18n(options) {
         if (options?.i18n instanceof i18n_1.I18n)
             return options.i18n;

package/cjs/implementation/http-adapter.js

@@ -0,0 +1,267 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpraHttpAdapter = void 0;
+const schema_1 = require("@opra/schema");
+const url_1 = require("@opra/url");
+const index_js_1 = require("../enums/index.js");
+const index_js_2 = require("../exception/index.js");
+const wrap_error_js_1 = require("../exception/wrap-error.js");
+const query_interface_js_1 = require("../interfaces/query.interface.js");
+const adapter_js_1 = require("./adapter.js");
+const query_context_js_1 = require("./query-context.js");
+class OpraHttpAdapter extends adapter_js_1.OpraAdapter {
+    prepareRequests(executionContext) {
+        const req = executionContext.getRequestWrapper();
+        // todo implement batch requests
+        if (this.isBatch(executionContext)) {
+            throw new Error('not implemented yet');
+        }
+        const url = new url_1.OpraURL(req.getUrl());
+        return [
+            this.prepareRequest(executionContext, url, req.getMethod(), new schema_1.ResponsiveMap(req.getHeaders()), req.getBody())
+        ];
+    }
+    prepareRequest(executionContext, url, method, headers, body) {
+        if (!url.path.size)
+            throw new index_js_2.BadRequestError();
+        if (method !== 'GET' && url.path.size > 1)
+            throw new index_js_2.BadRequestError();
+        const query = this.buildQuery(url, method, body);
+        if (!query)
+            throw new index_js_2.MethodNotAllowedError({
+                message: `Method "${method}" is not allowed by target endpoint`
+            });
+        return new query_context_js_1.QueryContext({
+            service: this.service,
+            executionContext,
+            query,
+            headers,
+            params: url.searchParams,
+            continueOnError: query.operation === 'read'
+        });
+    }
+    buildGetSchemaQuery(url) {
+        const pathLen = url.path.size;
+        const resourcePath = [];
+        let pathIndex = 0;
+        while (pathIndex < pathLen) {
+            const p = url.path.get(pathIndex++);
+            if (p.key)
+                throw new index_js_2.BadRequestError();
+            if (p.resource !== '$schema') {
+                if (pathIndex === 1)
+                    resourcePath.push('resources');
+                resourcePath.push(p.resource);
+            }
+        }
+        const opts = {
+            pick: url.searchParams.get('$pick'),
+            omit: url.searchParams.get('$omit'),
+            include: url.searchParams.get('$include'),
+        };
+        return query_interface_js_1.OpraQuery.forGetSchema(resourcePath, opts);
+    }
+    buildQuery(url, method, body) {
+        let container = this.service;
+        try {
+            const pathLen = url.path.size;
+            // Check if requesting metadata
+            for (let i = 0; i < pathLen; i++) {
+                const p = url.path.get(i);
+                if (p.resource === '$schema') {
+                    if (method !== 'GET')
+                        return;
+                    return this.buildGetSchemaQuery(url);
+                }
+            }
+            let pathIndex = 0;
+            while (pathIndex < pathLen) {
+                let p = url.path.get(pathIndex++);
+                const resource = container.getResource(p.resource);
+                // Move through path directories (containers)
+                if (resource instanceof schema_1.ContainerResource) {
+                    container = resource;
+                    continue;
+                }
+                method = method.toUpperCase();
+                if (resource instanceof schema_1.EntityResource) {
+                    const scope = p.key ? 'instance' : 'collection';
+                    if (pathIndex < pathLen && !(method === 'GET' && scope === 'instance'))
+                        return;
+                    let query;
+                    switch (method) {
+                        case 'GET': {
+                            if (scope === 'collection') {
+                                query = query_interface_js_1.OpraQuery.forSearch(resource, {
+                                    filter: url.searchParams.get('$filter'),
+                                    limit: url.searchParams.get('$limit'),
+                                    skip: url.searchParams.get('$skip'),
+                                    distinct: url.searchParams.get('$distinct'),
+                                    count: url.searchParams.get('$count'),
+                                    sort: url.searchParams.get('$sort'),
+                                    pick: url.searchParams.get('$pick'),
+                                    omit: url.searchParams.get('$omit'),
+                                    include: url.searchParams.get('$include'),
+                                });
+                            }
+                            else {
+                                query = query_interface_js_1.OpraQuery.forGetEntity(resource, p.key, {
+                                    pick: url.searchParams.get('$pick'),
+                                    omit: url.searchParams.get('$omit'),
+                                    include: url.searchParams.get('$include')
+                                });
+                                // Move through properties
+                                let nested;
+                                let path = resource.name;
+                                while (pathIndex < pathLen) {
+                                    const dataType = nested
+                                        ? this.service.getDataType(nested.property.type || 'string')
+                                        : query.resource.dataType;
+                                    if (!(dataType instanceof schema_1.ComplexType))
+                                        throw new Error(`"${path}" is not a ComplexType and has no fields.`);
+                                    p = url.path.get(pathIndex++);
+                                    path += '.' + p.resource;
+                                    const prop = dataType.fields.get(p.resource);
+                                    if (!prop)
+                                        throw new index_js_2.NotFoundError({ message: `Invalid or unknown resource path (${path})` });
+                                    const q = query_interface_js_1.OpraQuery.forGetProperty(prop);
+                                    if (nested) {
+                                        nested.nested = q;
+                                    }
+                                    else {
+                                        query.nested = q;
+                                    }
+                                    nested = q;
+                                }
+                            }
+                            break;
+                        }
+                        case 'DELETE': {
+                            if (scope === 'collection') {
+                                query = query_interface_js_1.OpraQuery.forDeleteMany(resource, {
+                                    filter: url.searchParams.get('$filter'),
+                                });
+                            }
+                            else {
+                                query = query_interface_js_1.OpraQuery.forDelete(resource, p.key);
+                            }
+                            break;
+                        }
+                        case 'POST': {
+                            if (scope === 'collection') {
+                                query = query_interface_js_1.OpraQuery.forCreate(resource, body, {
+                                    pick: url.searchParams.get('$pick'),
+                                    omit: url.searchParams.get('$omit'),
+                                    include: url.searchParams.get('$include')
+                                });
+                            }
+                            break;
+                        }
+                        case 'PATCH': {
+                            if (scope === 'collection') {
+                                query = query_interface_js_1.OpraQuery.forUpdateMany(resource, body, {
+                                    filter: url.searchParams.get('$filter')
+                                });
+                            }
+                            else {
+                                query = query_interface_js_1.OpraQuery.forUpdate(resource, p.key, body, {
+                                    pick: url.searchParams.get('$pick'),
+                                    omit: url.searchParams.get('$omit'),
+                                    include: url.searchParams.get('$include')
+                                });
+                            }
+                            break;
+                        }
+                    }
+                    return query;
+                }
+            }
+            throw new index_js_2.InternalServerError();
+        }
+        catch (e) {
+            throw index_js_2.BadRequestError.wrap(e);
+        }
+    }
+    async sendResponse(executionContext, queryContexts) {
+        const outputPackets = [];
+        for (const ctx of queryContexts) {
+            const v = this.createOutput(ctx);
+            outputPackets.push(v);
+        }
+        if (this.isBatch(executionContext)) {
+            // this.writeError([], new InternalServerError({message: 'Not implemented yet'}));
+            return;
+        }
+        if (!outputPackets.length) {
+            const err = new index_js_2.NotFoundError();
+            outputPackets.push({
+                status: err.status,
+                body: {
+                    errors: [err.response]
+                }
+            });
+        }
+        const out = outputPackets[0];
+        const resp = executionContext.getResponseWrapper();
+        resp.setStatus(out.status);
+        resp.setHeader(index_js_1.HttpHeaders.Content_Type, 'application/json');
+        resp.setHeader(index_js_1.HttpHeaders.Cache_Control, 'no-cache');
+        resp.setHeader(index_js_1.HttpHeaders.Pragma, 'no-cache');
+        resp.setHeader(index_js_1.HttpHeaders.Expires, '-1');
+        resp.setHeader(index_js_1.HttpHeaders.X_Opra_Version, schema_1.OpraSchema.Version);
+        if (out.headers) {
+            for (const [k, v] of Object.entries(out.headers)) {
+                resp.setHeader(k, v);
+            }
+        }
+        resp.send(JSON.stringify(out.body));
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    isBatch(executionContext) {
+        return false;
+    }
+    createOutput(ctx) {
+        const { query } = ctx;
+        let status = ctx.response.status;
+        let body = ctx.response.value || {};
+        const errors = ctx.response.errors?.map(e => (0, wrap_error_js_1.wrapError)(e));
+        if (errors && errors.length) {
+            if (!status || status < 400) {
+                status = 0;
+                for (const e of errors) {
+                    status = Math.max(status, e.status || status);
+                }
+                if (status < index_js_1.HttpStatus.BAD_REQUEST)
+                    status = index_js_1.HttpStatus.INTERNAL_SERVER_ERROR;
+            }
+            body.errors = errors.map(e => e.response);
+        }
+        else {
+            delete body.errors;
+            status = status || (query.operation === 'create' ? index_js_1.HttpStatus.CREATED : index_js_1.HttpStatus.OK);
+        }
+        // Convert headers map to object
+        const headers = Array.from(ctx.response.headers.keys()).map(k => k.toLowerCase()).sort()
+            .reduce((a, k) => {
+            a[k] = ctx.response.headers.get(k);
+            return a;
+        }, {});
+        body = this.i18n.deep(body);
+        return {
+            status,
+            headers,
+            body
+        };
+    }
+    async sendError(executionContext, error) {
+        const resp = executionContext.getResponseWrapper();
+        resp.setStatus(error.status || 500);
+        resp.setHeader(index_js_1.HttpHeaders.Content_Type, 'application/json');
+        resp.setHeader(index_js_1.HttpHeaders.Cache_Control, 'no-cache');
+        resp.setHeader(index_js_1.HttpHeaders.Pragma, 'no-cache');
+        resp.setHeader(index_js_1.HttpHeaders.Expires, '-1');
+        resp.setHeader(index_js_1.HttpHeaders.X_Opra_Version, schema_1.OpraSchema.Version);
+        resp.send(JSON.stringify(error.response));
+    }
+}
+exports.OpraHttpAdapter = OpraHttpAdapter;

package/cjs/implementation/query-context.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryResponse = exports.QueryContext = void 0;
+const schema_1 = require("@opra/schema");
 const url_1 = require("@opra/url");
-const headers_js_1 = require("../utils/headers.js");
+const index_js_1 = require("../enums/index.js");
 class QueryContext {
     service;
     executionContext;
@@ -18,7 +19,7 @@ class QueryContext {
         Object.assign(this, args);
         this.response = new QueryResponse();
         this.params = this.params || new url_1.OpraURLSearchParams();
-        this.headers = this.headers || headers_js_1.Headers.create();
+        this.headers = this.headers || new schema_1.ResponsiveMap();
         this.resultPath = this.resultPath || '';
     }
     get type() {
@@ -32,7 +33,7 @@ class QueryContext {
 }
 exports.QueryContext = QueryContext;
 class QueryResponse {
-    headers = headers_js_1.Headers.create();
+    headers;
     errors = [];
     status;
     value;
@@ -40,6 +41,7 @@ class QueryResponse {
     constructor(args) {
         if (args)
             Object.assign(this, args);
+        this.headers = new schema_1.ResponsiveMap(undefined, Array.from(Object.values(index_js_1.HttpHeaders)));
     }
 }
 exports.QueryResponse = QueryResponse;

package/cjs/index.js

@@ -2,25 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 require("reflect-metadata");
-tslib_1.__exportStar(require("./constants.js"), exports);
 tslib_1.__exportStar(require("./types.js"), exports);
 tslib_1.__exportStar(require("./enums/index.js"), exports);
 tslib_1.__exportStar(require("./exception/index.js"), exports);
-tslib_1.__exportStar(require("./decorators/entity-resource.decorator.js"), exports);
 tslib_1.__exportStar(require("./interfaces/execution-context.interface.js"), exports);
 tslib_1.__exportStar(require("./interfaces/query.interface.js"), exports);
-tslib_1.__exportStar(require("./interfaces/resource-container.interface.js"), exports);
+tslib_1.__exportStar(require("./interfaces/entity-service.interface.js"), exports);
 tslib_1.__exportStar(require("./implementation/query-context.js"), exports);
-tslib_1.__exportStar(require("./implementation/opra-document.js"), exports);
-tslib_1.__exportStar(require("./implementation/opra-service.js"), exports);
-tslib_1.__exportStar(require("./implementation/schema-generator.js"), exports);
-tslib_1.__exportStar(require("./implementation/adapter/adapter.js"), exports);
-tslib_1.__exportStar(require("./implementation/adapter/http-adapter.js"), exports);
-tslib_1.__exportStar(require("./implementation/adapter/express-adapter.js"), exports);
-tslib_1.__exportStar(require("./implementation/data-type/data-type.js"), exports);
-tslib_1.__exportStar(require("./implementation/data-type/complex-type.js"), exports);
-tslib_1.__exportStar(require("./implementation/data-type/simple-type.js"), exports);
-tslib_1.__exportStar(require("./implementation/resource/resource-handler.js"), exports);
-tslib_1.__exportStar(require("./implementation/resource/entity-resource-handler.js"), exports);
-tslib_1.__exportStar(require("./services/entity-resource-controller.js"), exports);
+tslib_1.__exportStar(require("./implementation/adapter.js"), exports);
+tslib_1.__exportStar(require("./implementation/http-adapter.js"), exports);
+tslib_1.__exportStar(require("./implementation/express-adapter.js"), exports);
+tslib_1.__exportStar(require("./services/data-service.js"), exports);
 tslib_1.__exportStar(require("./services/json-data-service.js"), exports);