@opra/core 0.0.12 → 0.1.0

package/cjs/implementation/resource/resource-handler.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ResourceHandler = void 0;
-const terminal_utils_js_1 = require("../../utils/terminal-utils.js");
-class ResourceHandler {
-    _args;
-    constructor(args) {
-        this._args = args;
-    }
-    get name() {
-        return this._args.name;
-    }
-    get description() {
-        return this._args.description;
-    }
-    toString() {
-        return `[${Object.getPrototypeOf(this).constructor.name} ${this.name}]`;
-    }
-    async prepare(ctx) {
-        const { query } = ctx;
-        const fn = this._args['pre_' + query.queryType];
-        if (fn && typeof fn === 'function') {
-            await fn(ctx);
-        }
-    }
-    [terminal_utils_js_1.nodeInspectCustom]() {
-        return `[${terminal_utils_js_1.colorFgYellow + Object.getPrototypeOf(this).constructor.name + terminal_utils_js_1.colorReset}` +
-            ` ${terminal_utils_js_1.colorFgMagenta + this.name + terminal_utils_js_1.colorReset}]`;
-    }
-}
-exports.ResourceHandler = ResourceHandler;

package/cjs/implementation/schema-generator.js

@@ -1,163 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SchemaGenerator = void 0;
-const types_1 = require("util/types");
-const schema_1 = require("@opra/schema");
-const constants_js_1 = require("../constants.js");
-const class_utils_js_1 = require("../utils/class-utils.js");
-const internal_data_types_js_1 = require("../utils/internal-data-types.js");
-var isDataType = schema_1.OpraSchema.isDataType;
-const entityMethods = ['search', 'count', 'create', 'get', 'update', 'updateMany', 'delete', 'deleteMany'];
-class SchemaGenerator {
-    _dataTypes = {};
-    _resources = {};
-    constructor() {
-        //
-    }
-    async addDataType(thunk) {
-        thunk = (0, types_1.isPromise)(thunk) ? await thunk : thunk;
-        if (typeof thunk === 'function') {
-            if (!(0, class_utils_js_1.isConstructor)(thunk))
-                return this.addDataType(await thunk());
-            if (internal_data_types_js_1.builtinClassMap.has(thunk))
-                return this.addDataType(internal_data_types_js_1.builtinClassMap.get(thunk));
-            const ctor = thunk;
-            const metadata = Reflect.getOwnMetadata(schema_1.DATATYPE_METADATA, ctor);
-            if (!metadata)
-                throw new TypeError(`Class "${ctor}" has no type metadata`);
-            // Add base data type
-            let base;
-            let baseCtor = Object.getPrototypeOf(ctor);
-            if (Reflect.hasMetadata(schema_1.DATATYPE_METADATA, baseCtor)) {
-                while (!Reflect.hasOwnMetadata(schema_1.DATATYPE_METADATA, baseCtor)) {
-                    baseCtor = Object.getPrototypeOf(baseCtor);
-                }
-                const baseSchema = await this.addDataType(baseCtor);
-                base = baseSchema.name;
-            }
-            const schema = {
-                ...metadata,
-                ctor,
-                base
-            };
-            const properties = Reflect.getMetadata(schema_1.DATATYPE_PROPERTIES, ctor.prototype);
-            if (properties) {
-                for (const [k, p] of Object.entries(properties)) {
-                    let type = p.type || 'string';
-                    if (typeof type !== 'string') {
-                        const propSchema = await this.addDataType(type);
-                        type = propSchema.name;
-                    }
-                    else {
-                        if (internal_data_types_js_1.internalDataTypes.has(type))
-                            await this.addDataType(internal_data_types_js_1.internalDataTypes.get(type));
-                    }
-                    schema.properties = schema.properties || {};
-                    schema.properties[k] = { ...p, type };
-                }
-            }
-            return this.addDataType(schema);
-        }
-        if (!isDataType(thunk))
-            throw new TypeError(`Invalid data type schema`);
-        // Check if datatype previously added
-        const currentSchema = this._dataTypes[thunk.name];
-        if (currentSchema) {
-            if (!(currentSchema.kind === thunk.kind && currentSchema.ctor && currentSchema.ctor === thunk.ctor))
-                throw new Error(`An other instance of "${currentSchema.name}" data type previously defined`);
-            return currentSchema;
-        }
-        if (schema_1.OpraSchema.isSimpleType(thunk) && !internal_data_types_js_1.primitiveDataTypeNames.includes(thunk.type))
-            throw new Error(`"type" of SimpleType schema must be one of enumerated value (${internal_data_types_js_1.primitiveDataTypeNames})`);
-        return this._dataTypes[thunk.name] = {
-            ...thunk
-        };
-    }
-    async addResource(instance) {
-        if ((0, class_utils_js_1.isConstructor)(instance))
-            throw new Error(`You should provide Resource instance instead of Resource class`);
-        const proto = Object.getPrototypeOf(instance);
-        const ctor = proto.constructor;
-        const metadata = Reflect.getMetadata(constants_js_1.RESOURCE_METADATA, ctor);
-        let resourceSchema;
-        if (metadata) {
-            const name = metadata.name || ctor.name.replace(/Resource$/, '');
-            const t = typeof metadata.type === 'function'
-                ? await (0, class_utils_js_1.resolveClassAsync)(metadata.type)
-                : metadata.type;
-            const type = typeof t === 'function'
-                ? (await this.addDataType(t)).name
-                : t;
-            resourceSchema = {
-                ...metadata,
-                type,
-                name,
-                instance
-            };
-            if (schema_1.OpraSchema.isEntityResource(resourceSchema)) {
-                for (const methodName of entityMethods) {
-                    let fn = instance['pre_' + methodName];
-                    if (typeof fn === 'function')
-                        resourceSchema['pre_' + methodName] = fn.bind(instance);
-                    fn = instance[methodName];
-                    if (typeof fn === 'function')
-                        resourceSchema[methodName] = fn.bind(instance);
-                }
-            }
-        }
-        else
-            resourceSchema = instance;
-        if (schema_1.OpraSchema.isResource(resourceSchema)) {
-            if (schema_1.OpraSchema.isEntityResource(resourceSchema)) {
-                const t = this._dataTypes[resourceSchema.type];
-                if (!t)
-                    throw new Error(`Resource registration error. Type "${resourceSchema.type}" not found.`);
-                if (this._resources[resourceSchema.name])
-                    throw new Error(`An other instance of "${resourceSchema.name}" resource previously defined`);
-                this._resources[resourceSchema.name] = resourceSchema;
-                return;
-            }
-            throw new Error(`Invalid resource metadata`);
-        }
-        throw new Error(`Invalid resource object`);
-    }
-    static async generateDocumentSchema(args) {
-        const generator = new SchemaGenerator();
-        if (args.types) {
-            for (const thunk of args.types) {
-                await generator.addDataType(thunk);
-            }
-        }
-        const types = Object.keys(generator._dataTypes).sort()
-            .map(name => generator._dataTypes[name]);
-        return {
-            version: '1',
-            ...args,
-            types
-        };
-    }
-    static async generateServiceSchema(args) {
-        const generator = new SchemaGenerator();
-        if (args.types) {
-            for (const thunk of args.types) {
-                await generator.addDataType(thunk);
-            }
-        }
-        if (args.resources) {
-            for (const resource of args.resources) {
-                await generator.addResource(resource);
-            }
-        }
-        const types = Object.keys(generator._dataTypes).sort()
-            .map(name => generator._dataTypes[name]);
-        const resources = Object.keys(generator._resources).sort()
-            .map(name => generator._resources[name]);
-        return {
-            version: '1',
-            ...args,
-            types,
-            resources
-        };
-    }
-}
-exports.SchemaGenerator = SchemaGenerator;

package/cjs/interfaces/opra-schema.metadata.js

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

package/cjs/interfaces/resource-container.interface.js

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

package/cjs/utils/class-utils.js

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isInternalClass = exports.resolveClassAsync = exports.resolveClass = exports.isConstructor = void 0;
-const knownInternalClasses = [String, Number, Boolean, Date];
-function isConstructor(obj) {
-    return typeof obj === 'function' &&
-        !!(obj.prototype && obj.prototype.constructor);
-}
-exports.isConstructor = isConstructor;
-function resolveClass(typeOrFunc) {
-    if (typeof typeOrFunc === 'function' && !isConstructor(typeOrFunc)) {
-        typeOrFunc = typeOrFunc();
-        if (isConstructor(typeOrFunc))
-            return typeOrFunc;
-        throw new TypeError(`Function must return a constructor`);
-    }
-    if (isConstructor(typeOrFunc))
-        return typeOrFunc;
-    throw new TypeError(`${typeOrFunc} is not a constructor`);
-}
-exports.resolveClass = resolveClass;
-async function resolveClassAsync(typeOrFunc) {
-    if (typeof typeOrFunc === 'function' && !isConstructor(typeOrFunc)) {
-        typeOrFunc = await typeOrFunc();
-        if (isConstructor(typeOrFunc))
-            return typeOrFunc;
-        throw new TypeError(`Function must return a constructor`);
-    }
-    if (isConstructor(typeOrFunc))
-        return typeOrFunc;
-    throw new TypeError(`${typeOrFunc} is not a constructor`);
-}
-exports.resolveClassAsync = resolveClassAsync;
-function isInternalClass(t) {
-    return knownInternalClasses.includes(t) || Buffer.isBuffer(t);
-}
-exports.isInternalClass = isInternalClass;

package/cjs/utils/headers.js

@@ -1,58 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Headers = void 0;
-const index_js_1 = require("../enums/index.js");
-const wellKnownHeaders = Object.values(index_js_1.HttpHeaders)
-    .reduce((target, k) => {
-    target[k.toLowerCase()] = k;
-    return target;
-}, {});
-const wrapKey = (prop) => {
-    return typeof prop == 'string' ? wellKnownHeaders[prop.toLowerCase()] || prop : prop;
-};
-/**
- * Create a proxy that ensures header keys are always formatted according to well known header names
- */
-var Headers;
-(function (Headers) {
-    function from(obj) {
-        const headers = create();
-        for (const [k, v] of Object.entries(obj))
-            headers[k] = v;
-        return headers;
-    }
-    Headers.from = from;
-    function create() {
-        return new Proxy({}, {
-            set: (target, prop, value, receiver) => {
-                let key = prop;
-                if (typeof key === 'string')
-                    key = wellKnownHeaders[key.toLowerCase()] || key;
-                const result = Reflect.set(target, key, value, receiver);
-                /*  istanbul ignore next */
-                if (!result && Object.isFrozen(target))
-                    throw new TypeError('Cannot add property, object is not extensible');
-                return result;
-            },
-            get: (target, prop, receiver) => {
-                return Reflect.get(target, wrapKey(prop), receiver);
-            },
-            deleteProperty: (target, prop) => {
-                return Reflect.deleteProperty(target, wrapKey(prop));
-            },
-            defineProperty: (target, prop, descriptor) => {
-                let key = prop;
-                if (typeof key === 'string')
-                    key = wellKnownHeaders[key.toLowerCase()] || key;
-                return Reflect.defineProperty(target, key, descriptor);
-            },
-            getOwnPropertyDescriptor: (target, prop) => {
-                return Reflect.getOwnPropertyDescriptor(target, wrapKey(prop));
-            },
-            has: (target, prop) => {
-                return Reflect.has(target, wrapKey(prop));
-            }
-        });
-    }
-    Headers.create = create;
-})(Headers = exports.Headers || (exports.Headers = {}));

package/cjs/utils/internal-data-types.js

@@ -1,81 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.internalDataTypes = exports.builtinClassMap = exports.primitiveDataTypeNames = void 0;
-exports.primitiveDataTypeNames = ['boolean', 'number', 'string', 'null'];
-exports.builtinClassMap = new Map();
-exports.internalDataTypes = new Map();
-const internalDataTypeArray = [
-    {
-        kind: 'SimpleType',
-        name: 'boolean',
-        type: 'boolean',
-        description: 'Simple true/false value',
-        ctor: Boolean
-    },
-    {
-        kind: 'SimpleType',
-        name: 'string',
-        type: 'string',
-        description: 'A sequence of characters',
-        ctor: String
-    },
-    {
-        kind: 'SimpleType',
-        name: 'number',
-        type: 'number',
-        description: 'Both Integer as well as Floating-Point numbers',
-        ctor: Number
-    },
-    {
-        kind: 'SimpleType',
-        name: 'integer',
-        type: 'number',
-        base: 'number',
-        description: 'Integer number',
-        ctor: Number
-    },
-    {
-        kind: 'ComplexType',
-        name: 'object',
-        description: 'Object type with additional properties',
-        additionalProperties: true,
-        ctor: Object
-    },
-    {
-        kind: 'SimpleType',
-        name: 'date',
-        type: 'string',
-        description: 'Date',
-        format: 'date',
-        ctor: Date
-    },
-    {
-        kind: 'SimpleType',
-        name: 'date-time',
-        type: 'string',
-        description: 'Date time value',
-        format: 'date-time',
-        ctor: Date
-    },
-    {
-        kind: 'SimpleType',
-        name: 'time',
-        type: 'string',
-        description: 'Time value',
-        format: 'time',
-        ctor: String
-    },
-    {
-        kind: 'SimpleType',
-        name: 'buffer',
-        type: 'string',
-        description: 'Buffer value',
-        format: 'base64',
-        ctor: Buffer
-    }
-];
-internalDataTypeArray.forEach(sch => {
-    exports.internalDataTypes.set(sch.name, sch);
-    if (sch.ctor && !exports.builtinClassMap.has(sch.ctor))
-        exports.builtinClassMap.set(sch.ctor, sch);
-});

package/cjs/utils/responsive-object.js

@@ -1,49 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Responsive = void 0;
-function Responsive(wrapped) {
-    wrapped = wrapped || {};
-    const keyMap = {};
-    Object.keys(wrapped).forEach(k => keyMap[k.toLowerCase()] = k);
-    const wrapKey = (prop) => {
-        return typeof prop == 'string' ? keyMap[prop.toLowerCase()] : prop;
-    };
-    return new Proxy(wrapped, {
-        set: (target, prop, value, receiver) => {
-            let key = prop;
-            if (typeof key === 'string') {
-                const keyLower = key.toLowerCase();
-                key = keyMap[keyLower] = keyMap[keyLower] || key;
-            }
-            const result = Reflect.set(target, key, value, receiver);
-            if (!result && Object.isFrozen(target))
-                throw new TypeError('Cannot add property, object is not extensible');
-            return result;
-        },
-        get: (target, prop, receiver) => {
-            return Reflect.get(target, wrapKey(prop), receiver);
-        },
-        deleteProperty: (target, prop) => {
-            const key = wrapKey(prop);
-            if (typeof prop === 'string') {
-                delete keyMap[prop.toLowerCase()];
-            }
-            return Reflect.deleteProperty(target, key);
-        },
-        defineProperty: (target, prop, descriptor) => {
-            let key = prop;
-            if (typeof key === 'string') {
-                const keyLower = key.toLowerCase();
-                key = keyMap[keyLower] = keyMap[keyLower] || key;
-            }
-            return Reflect.defineProperty(target, key, descriptor);
-        },
-        getOwnPropertyDescriptor: (target, prop) => {
-            return Reflect.getOwnPropertyDescriptor(target, wrapKey(prop));
-        },
-        has: (target, prop) => {
-            return Reflect.has(target, wrapKey(prop));
-        }
-    });
-}
-exports.Responsive = Responsive;

package/cjs/utils/terminal-utils.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.colorFgMagenta = exports.colorFgYellow = exports.colorReset = exports.nodeInspectCustom = void 0;
-exports.nodeInspectCustom = Symbol.for('nodejs.util.inspect.custom');
-exports.colorReset = "\x1b[0m";
-exports.colorFgYellow = "\x1b[33m";
-exports.colorFgMagenta = "\x1b[35m";

package/esm/constants.d.ts

@@ -1,2 +0,0 @@
-export declare const OpraVersion = "1.0";
-export declare const RESOURCE_METADATA = "opra:resource.metadata";

package/esm/constants.js

@@ -1,2 +0,0 @@
-export const OpraVersion = '1.0';
-export const RESOURCE_METADATA = 'opra:resource.metadata';

package/esm/decorators/entity-resource.decorator.d.ts

@@ -1,5 +0,0 @@
-import "reflect-metadata";
-import { EntityResourceMetadata } from '../interfaces/opra-schema.metadata.js';
-import { TypeThunkAsync } from '../types.js';
-export declare type EntityResourceOptions = Pick<EntityResourceMetadata, 'name' | 'description'> & {};
-export declare function ApiEntityResource(entityFunc: TypeThunkAsync, options?: EntityResourceOptions): (target: Function) => void;

package/esm/decorators/entity-resource.decorator.js

@@ -1,19 +0,0 @@
-import "reflect-metadata";
-import _ from 'lodash';
-import { RESOURCE_METADATA } from '../constants.js';
-const NESTJS_INJECTABLE_WATERMARK = '__injectable__';
-const NAME_PATTERN = /^(.*)Resource$/;
-export function ApiEntityResource(entityFunc, options) {
-    return function (target) {
-        const name = options?.name || target.name.match(NAME_PATTERN)?.[1] || target.name;
-        const meta = {
-            kind: 'EntityResource',
-            type: entityFunc,
-            name
-        };
-        Object.assign(meta, _.omit(options, Object.keys(meta)));
-        Reflect.defineMetadata(RESOURCE_METADATA, meta, target);
-        /* Define Injectable metadata for NestJS support*/
-        Reflect.defineMetadata(NESTJS_INJECTABLE_WATERMARK, true, target);
-    };
-}