@opra/core 0.0.13 → 0.1.0

package/esm/implementation/schema-generator.js

@@ -1,180 +0,0 @@
-import { isPromise } from 'util/types';
-import { DATATYPE_METADATA, DATATYPE_PROPERTIES, OpraSchema } from '@opra/schema';
-import { RESOLVER_METADATA, RESOURCE_METADATA } from '../constants.js';
-import { isConstructor, resolveClassAsync } from '../utils/class-utils.js';
-import { builtinClassMap, internalDataTypes, primitiveDataTypeNames } from '../utils/internal-data-types.js';
-const entityMethods = ['search', 'count', 'create', 'get', 'update', 'updateMany', 'delete', 'deleteMany'];
-export class SchemaGenerator {
-    _dataTypes = {};
-    _resources = {};
-    constructor() {
-        //
-    }
-    async addDataType(thunk) {
-        thunk = isPromise(thunk) ? await thunk : thunk;
-        if (typeof thunk === 'function') {
-            if (!isConstructor(thunk))
-                return this.addDataType(await thunk());
-            if (builtinClassMap.has(thunk))
-                return this.addDataType(builtinClassMap.get(thunk));
-            const ctor = thunk;
-            const metadata = Reflect.getOwnMetadata(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(DATATYPE_METADATA, baseCtor)) {
-                while (!Reflect.hasOwnMetadata(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(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 (internalDataTypes.has(type))
-                            await this.addDataType(internalDataTypes.get(type));
-                    }
-                    schema.properties = schema.properties || {};
-                    schema.properties[k] = { ...p, type };
-                }
-            }
-            return this.addDataType(schema);
-        }
-        if (!OpraSchema.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 (OpraSchema.isSimpleType(thunk) && !primitiveDataTypeNames.includes(thunk.type))
-            throw new Error(`"type" of SimpleType schema must be one of enumerated value (${primitiveDataTypeNames})`);
-        return this._dataTypes[thunk.name] = {
-            ...thunk
-        };
-    }
-    async addResource(instance) {
-        if (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(RESOURCE_METADATA, ctor);
-        let resourceSchema;
-        if (metadata) {
-            const name = metadata.name || ctor.name.replace(/Resource$/, '');
-            const t = typeof metadata.type === 'function'
-                ? await resolveClassAsync(metadata.type)
-                : metadata.type;
-            const type = typeof t === 'function'
-                ? (await this.addDataType(t)).name
-                : t;
-            resourceSchema = {
-                ...metadata,
-                type,
-                name,
-                instance,
-                resolvers: {}
-            };
-            if (OpraSchema.isEntityResource(resourceSchema)) {
-                for (const methodName of entityMethods) {
-                    let fn = instance[methodName];
-                    if (typeof fn === 'function') {
-                        const info = resourceSchema.resolvers[methodName] = {
-                            ...Reflect.getMetadata(RESOLVER_METADATA, proto, methodName)
-                        };
-                        if (!info.forbidden) {
-                            info.handler = fn.bind(instance);
-                            fn = instance['pre_' + methodName];
-                            if (typeof fn === 'function')
-                                resourceSchema['pre_' + methodName] = fn.bind(instance);
-                        }
-                    }
-                    else
-                        resourceSchema.resolvers[methodName] = { forbidden: true };
-                }
-            }
-        }
-        else
-            resourceSchema = instance;
-        if (OpraSchema.isResource(resourceSchema)) {
-            if (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)
-            .map(name => generator._dataTypes[name])
-            .sort((a, b) => {
-            if (a.kind !== b.kind) {
-                if (a.kind === 'SimpleType')
-                    return -1;
-                if (b.kind === 'SimpleType')
-                    return 1;
-                if (a.kind === 'ComplexType')
-                    return -1;
-                if (b.kind === 'ComplexType')
-                    return 1;
-            }
-            return (a.name < b.name ? -1 : 1);
-        });
-        const resources = Object.keys(generator._resources).sort()
-            .map(name => generator._resources[name]);
-        return {
-            version: '1',
-            ...args,
-            types,
-            resources
-        };
-    }
-}

package/esm/interfaces/metadata/api-resolver.metadata.d.ts

@@ -1,3 +0,0 @@
-import { StrictOmit } from 'ts-gems';
-import { OpraSchema } from '@opra/schema';
-export declare type ApiResolverMetadata = StrictOmit<OpraSchema.ResolverInfo, 'handler'>;

package/esm/interfaces/metadata/api-resolver.metadata.js

@@ -1 +0,0 @@
-export {};

package/esm/interfaces/metadata/opra-schema.metadata.d.ts

@@ -1,7 +0,0 @@
-import { StrictOmit } from 'ts-gems';
-import { OpraSchema } from '@opra/schema';
-import { TypeThunkAsync } from '../../types.js';
-export declare type EntityResourceMetadata = StrictOmit<OpraSchema.EntityResource, 'type' | 'name' | 'resolvers'> & {
-    type: TypeThunkAsync | string;
-    name?: string;
-};

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

@@ -1,10 +0,0 @@
-export {};
-/*
-export type ResourceReadOperationMetadata = StrictOmit<OpraSchema.ResourceReadOperation, 'handler'>;
-export type ResourceSearchOperationMetadata = StrictOmit<OpraSchema.ResourceSearchOperation, 'handler'>;
-export type ResourceCreateOperationMetadata = StrictOmit<OpraSchema.ResourceCreateOperation, 'handler'>;
-export type ResourceUpdateOperationMetadata = StrictOmit<OpraSchema.ResourceUpdateOperation, 'handler'>;
-export type ResourcePatchOperationMetadata = StrictOmit<OpraSchema.ResourcePatchOperation, 'handler'>;
-export type ResourceDeleteOperationMetadata = StrictOmit<OpraSchema.ResourceDeleteOperation, 'handler'>;
-export type ResourceExecuteOperationMetadata = StrictOmit<OpraSchema.ResourceExecuteOperation, 'handler'>;
-*/

package/esm/interfaces/resource-container.interface.d.ts

@@ -1,6 +0,0 @@
-import { EntityResourceHandler } from '../implementation/resource/entity-resource-handler.js';
-import { ResourceHandler } from '../implementation/resource/resource-handler.js';
-export interface IResourceContainer {
-    getResource<T extends ResourceHandler>(name: string): T;
-    getEntityResource(name: string): EntityResourceHandler;
-}

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

@@ -1 +0,0 @@
-export {};

package/esm/utils/class-utils.d.ts

@@ -1,6 +0,0 @@
-import { Type } from 'ts-gems';
-import { TypeThunk, TypeThunkAsync } from '../types.js';
-export declare function isConstructor(obj: any): obj is Type;
-export declare function resolveClass<T>(typeOrFunc: TypeThunk<T>): Type<T>;
-export declare function resolveClassAsync<T>(typeOrFunc: TypeThunkAsync<T>): Promise<Type<T>>;
-export declare function isInternalClass(t: any): boolean;

package/esm/utils/class-utils.js

@@ -1,30 +0,0 @@
-const knownInternalClasses = [String, Number, Boolean, Date];
-export function isConstructor(obj) {
-    return typeof obj === 'function' &&
-        !!(obj.prototype && obj.prototype.constructor);
-}
-export 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`);
-}
-export 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`);
-}
-export function isInternalClass(t) {
-    return knownInternalClasses.includes(t) || Buffer.isBuffer(t);
-}

package/esm/utils/headers.d.ts

@@ -1,9 +0,0 @@
-import { Opaque } from 'ts-gems';
-export declare type HeadersObject = Opaque<Record<string, any>, 'HeadersObject'>;
-/**
- * Create a proxy that ensures header keys are always formatted according to well known header names
- */
-export declare namespace Headers {
-    function from(obj: object): HeadersObject;
-    function create(): HeadersObject;
-}

package/esm/utils/headers.js

@@ -1,55 +0,0 @@
-import { HttpHeaders } from '../enums/index.js';
-const wellKnownHeaders = Object.values(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
- */
-export 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 || (Headers = {}));

package/esm/utils/internal-data-types.d.ts

@@ -1,5 +0,0 @@
-import { Type } from 'ts-gems';
-import { OpraSchema } from '@opra/schema';
-export declare const primitiveDataTypeNames: string[];
-export declare const builtinClassMap: Map<Type<any>, OpraSchema.DataType>;
-export declare const internalDataTypes: Map<string, OpraSchema.DataType>;

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

@@ -1,78 +0,0 @@
-export const primitiveDataTypeNames = ['boolean', 'number', 'string', 'null'];
-export const builtinClassMap = new Map();
-export const 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 => {
-    internalDataTypes.set(sch.name, sch);
-    if (sch.ctor && !builtinClassMap.has(sch.ctor))
-        builtinClassMap.set(sch.ctor, sch);
-});

package/esm/utils/responsive-object.d.ts

@@ -1,3 +0,0 @@
-import { Opaque } from 'ts-gems';
-export declare type ResponsiveObject<T> = Opaque<Record<string, T>, 'ResponsiveObject'>;
-export declare function Responsive<T>(wrapped?: Record<string, T>): ResponsiveObject<T>;

package/esm/utils/responsive-object.js

@@ -1,45 +0,0 @@
-export 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));
-        }
-    });
-}

package/esm/utils/string-path-to-object-tree.d.ts

@@ -1,4 +0,0 @@
-export interface ObjectTree {
-    [key: string]: boolean | ObjectTree;
-}
-export declare function stringPathToObjectTree(arr: string[]): ObjectTree | undefined;

package/esm/utils/terminal-utils.d.ts

@@ -1,4 +0,0 @@
-export declare const nodeInspectCustom: unique symbol;
-export declare const colorReset = "\u001B[0m";
-export declare const colorFgYellow = "\u001B[33m";
-export declare const colorFgMagenta = "\u001B[35m";

package/esm/utils/terminal-utils.js

@@ -1,4 +0,0 @@
-export const nodeInspectCustom = Symbol.for('nodejs.util.inspect.custom');
-export const colorReset = "\x1b[0m";
-export const colorFgYellow = "\x1b[33m";
-export const colorFgMagenta = "\x1b[35m";