@opra/core 0.3.0 → 0.5.0

package/cjs/adapter/adapter.js

@@ -0,0 +1,318 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpraAdapter = void 0;
+const strict_typed_events_1 = require("strict-typed-events");
+const common_1 = require("@opra/common");
+const exception_1 = require("@opra/exception");
+const i18n_1 = require("@opra/i18n");
+const schema_1 = require("@opra/schema");
+const create_i18n_js_1 = require("../utils/create-i18n.js");
+const metadata_resource_js_1 = require("./metadata-resource.js");
+class OpraAdapter {
+    document;
+    i18n;
+    userContextResolver;
+    // protected _metadataResource: SingletonResourceInfo;
+    _internalResources = new common_1.ResponsiveMap();
+    constructor(document) {
+        this.document = document;
+    }
+    async handler(executionContext) {
+        let queryContexts;
+        let userContext;
+        let failed = false;
+        try {
+            queryContexts = this.prepareRequests(executionContext);
+            let stop = false;
+            // Read requests can be executed simultaneously, write request should be executed one by one
+            let promises;
+            let exclusive = false;
+            for (const context of queryContexts) {
+                exclusive = exclusive || context.query.operation !== 'read';
+                // Wait previous read requests before executing update request
+                if (exclusive && promises) {
+                    await Promise.allSettled(promises);
+                    promises = undefined;
+                }
+                // If previous request in bucket had an error and executed an update
+                // we do not execute next requests
+                if (stop) {
+                    context.errors.push(new exception_1.FailedDependencyError());
+                    continue;
+                }
+                try {
+                    const promise = (async () => {
+                        // if (context.query.method === 'metadata') {
+                        //   await this._getSchemaExecute(context); //todo
+                        //   return;
+                        // }
+                        const resource = context.query.resource;
+                        await this._resourcePrepare(resource, context);
+                        if (this.userContextResolver && !userContext)
+                            userContext = this.userContextResolver({
+                                executionContext,
+                                isBatch: this.isBatch(executionContext)
+                            });
+                        context.userContext = userContext;
+                        await this._resourceExecute(this.document, resource, context);
+                    })().catch(e => {
+                        context.errors.push(e);
+                    });
+                    if (exclusive)
+                        await promise;
+                    else {
+                        promises = promises || [];
+                        promises.push(promise);
+                    }
+                    // todo execute sub property queries
+                }
+                catch (e) {
+                    context.errors.unshift(e);
+                }
+                if (context.errors.length) {
+                    // noinspection SuspiciousTypeOfGuard
+                    context.errors = context.errors.map(e => (0, exception_1.wrapException)(e));
+                    if (exclusive)
+                        stop = stop || !!context.errors.find(e => !(e.issue.severity === 'warning' || e.issue.severity === 'info'));
+                }
+            }
+            if (promises)
+                await Promise.allSettled(promises);
+            await this.sendResponse(executionContext, queryContexts);
+        }
+        catch (e) {
+            failed = true;
+            const error = (0, exception_1.wrapException)(e);
+            await this.sendError(executionContext, error);
+        }
+        finally {
+            if (executionContext instanceof strict_typed_events_1.AsyncEventEmitter) {
+                await executionContext
+                    .emitAsyncSerial('finish', {
+                    userContext,
+                    failed
+                }).catch();
+            }
+        }
+    }
+    async _resourcePrepare(resource, context) {
+        const { query } = context;
+        const fn = resource.metadata['pre_' + query.method];
+        if (fn && typeof fn === 'function') {
+            await fn(context);
+        }
+    }
+    async _resourceExecute(document, resource, context) {
+        if (resource instanceof schema_1.CollectionResourceInfo) {
+            const { query } = context;
+            if (query.kind === 'SearchCollectionQuery') {
+                const promises = [];
+                let search;
+                promises.push(this._collectionResourceExecute(document, resource, context)
+                    .then(v => search = v));
+                if (query.count && resource.metadata.count) {
+                    const ctx = {
+                        query: new schema_1.CollectionCountQuery(query.resource, { filter: query.filter }),
+                        resultPath: ''
+                    };
+                    Object.setPrototypeOf(ctx, context);
+                    promises.push(this._collectionResourceExecute(document, resource, ctx));
+                }
+                await Promise.all(promises);
+                context.response = search;
+                return;
+            }
+            context.response = await this._collectionResourceExecute(document, resource, context);
+            return;
+        }
+        else if (resource instanceof schema_1.SingletonResourceInfo) {
+            context.response = await this._singletonResourceExecute(document, resource, context);
+            return;
+        }
+        throw new Error(`Executing "${resource.kind}" has not been implemented yet`);
+    }
+    async _init(options) {
+        if (options?.i18n instanceof i18n_1.I18n)
+            this.i18n = options.i18n;
+        else if (typeof options?.i18n === 'function')
+            this.i18n = await options.i18n();
+        else
+            this.i18n = await (0, create_i18n_js_1.createI18n)(options?.i18n);
+        this.i18n = this.i18n || i18n_1.I18n.defaultInstance;
+        if (!this.i18n.isInitialized)
+            await this.i18n.init();
+        this.userContextResolver = options?.userContext;
+        const metadataResource = new metadata_resource_js_1.MetadataResource();
+        const metadataResourceInfo = new schema_1.SingletonResourceInfo(this.document, '$metadata', this.document.getComplexDataType('object'), {
+            kind: 'SingletonResource',
+            type: 'object',
+            instance: metadataResource,
+            get: {
+                handler: metadataResource.get.bind(metadataResource)
+            }
+        });
+        this._internalResources.set(metadataResourceInfo.name, metadataResourceInfo);
+        metadataResource.init(metadataResourceInfo);
+        for (const r of this.document.resources.values()) {
+            if (r.instance) {
+                const init = r.instance.init;
+                if (init)
+                    await init.call(r.instance, r);
+            }
+        }
+    }
+    async _collectionResourceExecute(document, resource, context) {
+        const method = context.query.method;
+        const resolverInfo = resource.metadata[method];
+        if (!(resolverInfo && resolverInfo.handler))
+            throw new exception_1.ForbiddenError({
+                message: (0, i18n_1.translate)('RESOLVER_FORBIDDEN', { method }, `The resource endpoint does not accept '{{method}}' operations`),
+                severity: 'error',
+                code: 'RESOLVER_FORBIDDEN'
+            });
+        let result;
+        switch (method) {
+            case 'create': {
+                const query = context.query;
+                result = await resolverInfo.handler(context, query.data, query);
+                result = Array.isArray(result) ? result[0] : result;
+                if (result)
+                    context.status = 201;
+                context.responseHeaders.set(common_1.HttpHeaders.X_Opra_DataType, resource.dataType.name);
+                return result;
+            }
+            case 'count': {
+                const query = context.query;
+                result = await resolverInfo.handler(context, query);
+                context.responseHeaders.set(common_1.HttpHeaders.X_Opra_Count, result);
+                return result;
+            }
+            case 'get': {
+                const query = context.query;
+                result = await resolverInfo.handler(context, query.keyValue, query);
+                result = Array.isArray(result) ? result[0] : result;
+                if (!result)
+                    throw new exception_1.ResourceNotFoundError(resource.name, query.keyValue);
+                const v = await this._pathWalkThrough(query, query.dataType, result, resource.name);
+                if (v.value === undefined)
+                    throw new exception_1.ResourceNotFoundError(v.path);
+                if (v.dataType)
+                    context.responseHeaders.set(common_1.HttpHeaders.X_Opra_DataType, v.dataType.name);
+                return v.value;
+            }
+            case 'search': {
+                const query = context.query;
+                result = await resolverInfo.handler(context, query);
+                const items = Array.isArray(result) ? result : (context.response ? [result] : []);
+                context.responseHeaders.set(common_1.HttpHeaders.X_Opra_DataType, resource.dataType.name);
+                return items;
+            }
+            case 'update': {
+                const query = context.query;
+                result = await resolverInfo.handler(context, query.keyValue, query.data, query);
+                result = Array.isArray(result) ? result[0] : result;
+                if (!result)
+                    throw new exception_1.ResourceNotFoundError(resource.name, query.keyValue);
+                context.responseHeaders.set(common_1.HttpHeaders.X_Opra_DataType, resource.dataType.name);
+                return result;
+            }
+            case 'delete':
+            case 'deleteMany':
+            case 'updateMany': {
+                switch (method) {
+                    case 'delete': {
+                        const query = context.query;
+                        result = await resolverInfo.handler(context, query.keyValue, query);
+                        break;
+                    }
+                    case 'deleteMany': {
+                        const query = context.query;
+                        result = await resolverInfo.handler(context, query);
+                        break;
+                    }
+                    case 'updateMany': {
+                        const query = context.query;
+                        result = await resolverInfo.handler(context, query.data, query);
+                        break;
+                    }
+                }
+                let affected;
+                if (typeof result === 'number')
+                    affected = result;
+                if (typeof result === 'boolean')
+                    affected = result ? 1 : 0;
+                if (typeof result === 'object')
+                    affected = result.affectedRows || result.affected;
+                return {
+                    operation: context.query.method,
+                    affected
+                };
+            }
+        }
+    }
+    async _singletonResourceExecute(document, resource, context) {
+        const method = context.query.method;
+        const resolverInfo = resource.metadata[method];
+        if (!(resolverInfo && resolverInfo.handler))
+            throw new exception_1.ForbiddenError({
+                message: (0, i18n_1.translate)('RESOLVER_FORBIDDEN', { method }, `The resource endpoint does not accept '{{method}}' operations`),
+                severity: 'error',
+                code: 'RESOLVER_FORBIDDEN'
+            });
+        let result = await resolverInfo.handler(context);
+        switch (method) {
+            case 'get': {
+                const query = context.query;
+                result = await resolverInfo.handler(context, query);
+                result = Array.isArray(result) ? result[0] : result;
+                if (!result)
+                    throw new exception_1.ResourceNotFoundError(resource.name);
+                const v = await this._pathWalkThrough(query, query.dataType, result, resource.name);
+                if (v.value === undefined)
+                    throw new exception_1.ResourceNotFoundError(v.path);
+                if (v.dataType)
+                    context.responseHeaders.set(common_1.HttpHeaders.X_Opra_DataType, v.dataType.name);
+                return v.value;
+            }
+        }
+        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 ? this.document.types.get(prop.type) : undefined;
+                result = result && typeof result === 'object' && result[field];
+            }
+        }
+        if (method === 'create')
+            context.status = 201;
+        context.responseHeaders.set(common_1.HttpHeaders.X_Opra_DataType, resource.dataType.name);
+        return result;
+    }
+    async _pathWalkThrough(query, dataType, value, parentPath) {
+        const { child } = query;
+        if (!child)
+            return { value, dataType, path: parentPath };
+        // Make a case in sensitive lookup
+        const fieldNameLower = child.fieldName.toLowerCase();
+        const path = parentPath + (parentPath ? '.' : '') + child.fieldName;
+        for (const key of Object.keys(value)) {
+            if (key.toLowerCase() === fieldNameLower) {
+                let v = value[key];
+                if (v == null)
+                    return { path };
+                if (child.child && child.dataType instanceof schema_1.ComplexType) {
+                    if (Array.isArray(v))
+                        v = v[0];
+                    return this._pathWalkThrough(child, child.dataType, v, path);
+                }
+                return { value: v, dataType: child.dataType, path };
+            }
+        }
+        return { path };
+    }
+}
+exports.OpraAdapter = OpraAdapter;

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

@@ -7,12 +7,9 @@ const strict_typed_events_1 = require("strict-typed-events");
 const url_1 = require("@opra/url");
 const http_adapter_js_1 = require("./http-adapter.js");
 class OpraExpressAdapter extends http_adapter_js_1.OpraHttpAdapter {
-    static async init(app, service, options) {
-        const i18n = await this.initI18n(options);
-        const adapter = new OpraExpressAdapter(service, {
-            ...options,
-            i18n
-        });
+    static async init(app, document, options) {
+        const adapter = new OpraExpressAdapter(document);
+        await adapter._init(options);
         const prefix = '/' + (0, url_1.normalizePath)(options?.prefix, true);
         app.use(prefix, body_parser_1.default.json());
         app.use(prefix, (request, response, next) => {

package/cjs/adapter/http-adapter.js

@@ -0,0 +1,241 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpraHttpAdapter = void 0;
+const common_1 = require("@opra/common");
+const exception_1 = require("@opra/exception");
+const schema_1 = require("@opra/schema");
+const url_1 = require("@opra/url");
+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 common_1.HeadersMap(req.getHeaders()), req.getBody())
+        ];
+    }
+    prepareRequest(executionContext, url, method, headers, body) {
+        if (!url.path.size)
+            throw new exception_1.BadRequestError();
+        if (method !== 'GET' && url.path.size > 1)
+            throw new exception_1.BadRequestError();
+        const query = this.buildQuery(url, method, body);
+        if (!query)
+            throw new exception_1.MethodNotAllowedError({
+                message: `Method "${method}" is not allowed by target endpoint`
+            });
+        return new query_context_js_1.QueryContext({
+            service: this.document,
+            executionContext,
+            query,
+            headers: new common_1.HeadersMap(),
+            params: url.searchParams,
+            continueOnError: query.operation === 'read'
+        });
+    }
+    buildQuery(url, method, body) {
+        const pathLen = url.path.size;
+        let p = url.path.get(0);
+        let resource = this._internalResources.get(p.resource) || this.document.getResource(p.resource);
+        let container;
+        let pathIndex = 0;
+        while (resource && resource instanceof schema_1.ContainerResourceInfo) {
+            container = resource;
+            p = url.path.get(++pathIndex);
+            resource = container.getResource(p.resource);
+        }
+        try {
+            method = method.toUpperCase();
+            let query;
+            if (resource instanceof schema_1.SingletonResourceInfo && !p.key) {
+                switch (method) {
+                    case 'GET': {
+                        query = new schema_1.SingletonGetQuery(resource);
+                    }
+                }
+            }
+            else if (resource instanceof schema_1.CollectionResourceInfo) {
+                switch (method) {
+                    case 'GET': {
+                        if (p.key) {
+                            const searchParams = url.searchParams;
+                            query = new schema_1.CollectionGetQuery(resource, p.key, {
+                                pick: searchParams.get('$pick'),
+                                omit: searchParams.get('$omit'),
+                                include: searchParams.get('$include')
+                            });
+                        }
+                        else {
+                            const searchParams = url.searchParams;
+                            query = new schema_1.CollectionSearchQuery(resource, {
+                                filter: searchParams.get('$filter'),
+                                limit: searchParams.get('$limit'),
+                                skip: searchParams.get('$skip'),
+                                distinct: searchParams.get('$distinct'),
+                                count: searchParams.get('$count'),
+                                sort: searchParams.get('$sort'),
+                                pick: searchParams.get('$pick'),
+                                omit: searchParams.get('$omit'),
+                                include: searchParams.get('$include')
+                            });
+                        }
+                        break;
+                    }
+                    case 'DELETE': {
+                        const searchParams = url.searchParams;
+                        query = p.key
+                            ? new schema_1.CollectionDeleteQuery(resource, p.key)
+                            : new schema_1.CollectionDeleteManyQuery(resource, {
+                                filter: searchParams.get('$filter'),
+                            });
+                        break;
+                    }
+                    case 'POST': {
+                        if (!p.key) {
+                            const searchParams = url.searchParams;
+                            query = new schema_1.CollectionCreateQuery(resource, body, {
+                                pick: searchParams.get('$pick'),
+                                omit: searchParams.get('$omit'),
+                                include: searchParams.get('$include')
+                            });
+                        }
+                        break;
+                    }
+                    case 'PATCH': {
+                        if (p.key) {
+                            const searchParams = url.searchParams;
+                            query = new schema_1.CollectionUpdateQuery(resource, p.key, body, {
+                                pick: searchParams.get('$pick'),
+                                omit: searchParams.get('$omit'),
+                                include: searchParams.get('$include')
+                            });
+                        }
+                        else {
+                            const searchParams = url.searchParams;
+                            query = new schema_1.CollectionUpdateManyQuery(resource, body, {
+                                filter: searchParams.get('$filter')
+                            });
+                        }
+                        break;
+                    }
+                }
+            }
+            else
+                throw new exception_1.InternalServerError();
+            if (query instanceof schema_1.SingletonGetQuery || query instanceof schema_1.CollectionGetQuery || query instanceof schema_1.FieldGetQuery) {
+                // Move through properties
+                let parentType;
+                const curPath = [];
+                let parent = query;
+                while (++pathIndex < pathLen) {
+                    p = url.path.get(pathIndex);
+                    parentType = parent.dataType;
+                    if (parent.dataType instanceof schema_1.UnionType) {
+                        if (parent.dataType.name === 'any')
+                            parentType = this.document.getComplexDataType('object');
+                        else
+                            throw new TypeError(`"${resource.name}.${curPath.join()}" is a UnionType and needs type casting.`);
+                    }
+                    if (!(parentType instanceof schema_1.ComplexType))
+                        throw new TypeError(`"${resource.name}.${curPath.join()}" is not a ComplexType and has no fields.`);
+                    curPath.push(p.resource);
+                    parent.child = new schema_1.FieldGetQuery(parent, p.resource, { castingType: parentType });
+                    parent = parent.child;
+                }
+            }
+            return query;
+        }
+        catch (e) {
+            if (e instanceof exception_1.OpraException)
+                throw e;
+            throw new exception_1.BadRequestError(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)
+            return this.sendError(executionContext, new exception_1.NotFoundError());
+        const out = outputPackets[0];
+        const resp = executionContext.getResponseWrapper();
+        resp.setStatus(out.status);
+        resp.setHeader(common_1.HttpHeaders.Content_Type, 'application/json');
+        resp.setHeader(common_1.HttpHeaders.Cache_Control, 'no-cache');
+        resp.setHeader(common_1.HttpHeaders.Pragma, 'no-cache');
+        resp.setHeader(common_1.HttpHeaders.Expires, '-1');
+        resp.setHeader(common_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));
+        resp.end();
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    isBatch(executionContext) {
+        return false;
+    }
+    createOutput(ctx) {
+        const { query } = ctx;
+        let body;
+        let status = ctx.status || 0;
+        const errors = ctx.errors.map(e => (0, exception_1.wrapException)(e));
+        if (errors && errors.length) {
+            // Sort errors from fatal to info
+            errors.sort((a, b) => {
+                const i = exception_1.IssueSeverity.Keys.indexOf(a.issue.severity) - exception_1.IssueSeverity.Keys.indexOf(b.issue.severity);
+                if (i === 0)
+                    return b.status - a.status;
+                return i;
+            });
+            if (!status || status < common_1.HttpStatus.BAD_REQUEST) {
+                status = errors[0].status;
+                if (status < common_1.HttpStatus.BAD_REQUEST)
+                    status = common_1.HttpStatus.INTERNAL_SERVER_ERROR;
+            }
+            body = {
+                operation: ctx.query.method,
+                errors: errors.map(e => e.issue)
+            };
+        }
+        else {
+            body = ctx.response;
+            status = status || (query.operation === 'create' ? common_1.HttpStatus.CREATED : common_1.HttpStatus.OK);
+        }
+        body = this.i18n.deep(body);
+        return {
+            status,
+            headers: ctx.responseHeaders.toObject(),
+            body
+        };
+    }
+    async sendError(executionContext, error) {
+        const resp = executionContext.getResponseWrapper();
+        resp.setStatus(error.status || 500);
+        resp.setHeader(common_1.HttpHeaders.Content_Type, 'application/json');
+        resp.setHeader(common_1.HttpHeaders.Cache_Control, 'no-cache');
+        resp.setHeader(common_1.HttpHeaders.Pragma, 'no-cache');
+        resp.setHeader(common_1.HttpHeaders.Expires, '-1');
+        resp.setHeader(common_1.HttpHeaders.X_Opra_Version, schema_1.OpraSchema.Version);
+        const issue = this.i18n.deep(error.issue);
+        const body = {
+            operation: 'unknown',
+            errors: [issue]
+        };
+        resp.send(JSON.stringify(body));
+    }
+}
+exports.OpraHttpAdapter = OpraHttpAdapter;

package/cjs/adapter/metadata-resource.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetadataResource = void 0;
+const tslib_1 = require("tslib");
+const schema_1 = require("@opra/schema");
+const json_singleton_service_js_1 = require("../services/json-singleton-service.js");
+let MetadataResource = class MetadataResource {
+    service;
+    init(resource) {
+        this.service = new json_singleton_service_js_1.JsonSingletonService(resource.dataType, {
+            data: resource.document.getMetadata(true)
+        });
+    }
+    get() {
+        return this.service.get();
+    }
+};
+MetadataResource = tslib_1.__decorate([
+    (0, schema_1.OprSingletonResource)(Object, {
+        name: '$metadata'
+    })
+], MetadataResource);
+exports.MetadataResource = MetadataResource;

package/cjs/{implementation → adapter}/query-context.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryContext = void 0;
+const common_1 = require("@opra/common");
 const url_1 = require("@opra/url");
-const headers_map_js_1 = require("./headers-map.js");
 class QueryContext {
     service;
     executionContext;
@@ -24,8 +24,8 @@ class QueryContext {
         this.query = args.query;
         // this.response = new QueryResponse();
         this.params = this.params || new url_1.OpraURLSearchParams();
-        this.headers = new headers_map_js_1.HeadersMap(args.headers);
-        this.responseHeaders = new headers_map_js_1.HeadersMap();
+        this.headers = new common_1.HeadersMap(args.headers);
+        this.responseHeaders = new common_1.HeadersMap();
         this.resultPath = this.resultPath || '';
     }
     get type() {

package/cjs/index.js

@@ -3,12 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 require("reflect-metadata");
 tslib_1.__exportStar(require("./types.js"), exports);
-tslib_1.__exportStar(require("./enums/index.js"), exports);
 tslib_1.__exportStar(require("./interfaces/execution-context.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/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("./interfaces/resource.interface.js"), exports);
+tslib_1.__exportStar(require("./adapter/query-context.js"), exports);
+tslib_1.__exportStar(require("./adapter/adapter.js"), exports);
+tslib_1.__exportStar(require("./adapter/http-adapter.js"), exports);
+tslib_1.__exportStar(require("./adapter/express-adapter.js"), exports);
 tslib_1.__exportStar(require("./services/data-service.js"), exports);
 tslib_1.__exportStar(require("./services/json-collection-service.js"), exports);
+tslib_1.__exportStar(require("./services/json-singleton-service.js"), exports);

package/cjs/interfaces/resource.interface.js

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