@opra/core 0.0.5

package/esm/implementation/schema-generator.js

@@ -0,0 +1,169 @@
+import { isPromise } from 'util/types';
+import { DATATYPE_METADATA, DATATYPE_PROPERTIES, OpraSchema } from '@opra/schema';
+import { 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', 'create', 'read', 'update', 'updateMany', 'delete', 'deleteMany'];
+export class SchemaGenerator {
+    _dataTypes = {};
+    _resources = {};
+    constructor() {
+        //
+    }
+    async addDataType(thunk) {
+        let schema;
+        thunk = isPromise(thunk) ? await thunk : thunk;
+        if (typeof thunk === 'function' && !isConstructor(thunk))
+            thunk = await thunk();
+        if (!isConstructor(thunk) || OpraSchema.isDataType(thunk))
+            throw new TypeError(`Function must return a type class or type schema`);
+        if (isConstructor(thunk)) {
+            const ctor = thunk;
+            const metadata = Reflect.getOwnMetadata(DATATYPE_METADATA, ctor);
+            if (!metadata)
+                throw new TypeError(`Class "${ctor}" has no type metadata`);
+            schema = this._dataTypes[metadata.name];
+            if (schema) {
+                if (schema.kind !== metadata.kind ||
+                    (OpraSchema.isComplexType(schema) && schema.ctor !== ctor))
+                    throw new Error(`An other instance of "${schema.name}" data type previously defined`);
+                return schema;
+            }
+            // 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;
+            }
+            if (OpraSchema.isComplexType(metadata) || OpraSchema.isEntityType(metadata)) {
+                schema = {
+                    ...metadata,
+                    ctor,
+                    base
+                };
+                const properties = Reflect.getMetadata(DATATYPE_PROPERTIES, ctor.prototype);
+                if (properties) {
+                    for (const [k, p] of Object.entries(properties)) {
+                        let type;
+                        if (isConstructor(p.type) && builtinClassMap.has(p.type))
+                            type = builtinClassMap.get(p.type);
+                        else if (typeof p.type === 'function' || typeof p.type === 'object') {
+                            const t = await this.addDataType(p.type);
+                            type = t.name;
+                        }
+                        else
+                            type = p.type || 'string';
+                        if (internalDataTypes.has(type) && !this._dataTypes[type])
+                            this._dataTypes[type] = internalDataTypes.get(type.toLowerCase());
+                        schema.properties = schema.properties || {};
+                        schema.properties[k] = { ...p, type };
+                    }
+                }
+            }
+            else if (OpraSchema.isSimpleType(metadata)) {
+                if (!primitiveDataTypeNames.includes(metadata.type))
+                    throw new Error(`"type" of SimpleType schema must be one of enumerated value (${primitiveDataTypeNames})`);
+                schema = {
+                    ...metadata
+                };
+            }
+            else
+                /* istanbul ignore next */
+                throw new TypeError(`Invalid metadata`);
+        }
+        else if (OpraSchema.isDataType(thunk)) {
+            schema = thunk;
+        }
+        else
+            throw new TypeError(`Invalid data type schema`);
+        this._dataTypes[schema.name] = schema;
+        return schema;
+    }
+    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
+            };
+            if (OpraSchema.isEntityResource(resourceSchema)) {
+                for (const methodName of entityMethods) {
+                    const fn = instance[methodName];
+                    if (typeof fn === 'function') {
+                        resourceSchema[methodName] = fn.bind(instance);
+                    }
+                }
+            }
+        }
+        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).sort()
+            .map(name => generator._dataTypes[name]);
+        const resources = Object.keys(generator._resources).sort()
+            .map(name => generator._resources[name]);
+        return {
+            version: '1',
+            ...args,
+            types,
+            resources
+        };
+    }
+}

package/esm/index.d.ts

@@ -0,0 +1,22 @@
+import "reflect-metadata";
+export * from './constants.js';
+export * from './types.js';
+export * from './enums/index.js';
+export * from './exception/index.js';
+export * from './decorators/entity-resource.decorator.js';
+export * from './interfaces/http-context.interface.js';
+export * from './interfaces/execution-query.interface.js';
+export * from './interfaces/entity-resource.interface.js';
+export * from './interfaces/resource-container.interface.js';
+export * from './implementation/execution-context.js';
+export * from './implementation/opra-document.js';
+export * from './implementation/opra-service.js';
+export * from './implementation/schema-generator.js';
+export * from './implementation/adapter/adapter.js';
+export * from './implementation/adapter/express-adapter.js';
+export * from './implementation/data-type/data-type.js';
+export * from './implementation/data-type/complex-type.js';
+export * from './implementation/data-type/simple-type.js';
+export * from './implementation/resource/resource-info.js';
+export * from './implementation/resource/entity-resource-info.js';
+export * from './services/json-data-service.js';

package/esm/index.js

@@ -0,0 +1,22 @@
+import "reflect-metadata";
+export * from './constants.js';
+export * from './types.js';
+export * from './enums/index.js';
+export * from './exception/index.js';
+export * from './decorators/entity-resource.decorator.js';
+export * from './interfaces/http-context.interface.js';
+export * from './interfaces/execution-query.interface.js';
+export * from './interfaces/entity-resource.interface.js';
+export * from './interfaces/resource-container.interface.js';
+export * from './implementation/execution-context.js';
+export * from './implementation/opra-document.js';
+export * from './implementation/opra-service.js';
+export * from './implementation/schema-generator.js';
+export * from './implementation/adapter/adapter.js';
+export * from './implementation/adapter/express-adapter.js';
+export * from './implementation/data-type/data-type.js';
+export * from './implementation/data-type/complex-type.js';
+export * from './implementation/data-type/simple-type.js';
+export * from './implementation/resource/resource-info.js';
+export * from './implementation/resource/entity-resource-info.js';
+export * from './services/json-data-service.js';

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

@@ -0,0 +1,9 @@
+export interface IEntityResource {
+    search?(...args: any[]): any;
+    read?(...args: any[]): any;
+    create?(...args: any[]): any;
+    update?(...args: any[]): any;
+    updateMany?(...args: any[]): any;
+    delete?(...args: any[]): any;
+    deleteMany?(...args: any[]): any;
+}

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

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

package/esm/interfaces/execution-query.interface.d.ts

@@ -0,0 +1,102 @@
+import { StrictOmit } from 'ts-gems';
+import { OpraSchema } from '@opra/schema';
+import { Expression } from '@opra/url';
+import { EntityResourceInfo } from '../implementation/resource/entity-resource-info.js';
+import { KeyValue, OperationType, QueryScope, QueryType } from '../types.js';
+export declare type ExecutionQuery = CreateQuery | ReadQuery | SearchQuery | UpdateQuery | UpdateManyQuery | DeleteQuery | DeleteManyQuery;
+interface BaseQuery {
+    queryType: QueryType;
+    scope: QueryScope;
+    operationType: OperationType;
+}
+export interface CreateQuery extends BaseQuery {
+    queryType: 'create';
+    scope: 'collection';
+    operationType: 'create';
+    resource: EntityResourceInfo;
+    data: {};
+    pick?: string[];
+    omit?: string[];
+    include?: string[];
+}
+export interface ReadQuery extends BaseQuery {
+    queryType: 'read';
+    scope: 'instance';
+    operationType: 'read';
+    resource: EntityResourceInfo;
+    keyValue: KeyValue;
+    pick?: string[];
+    omit?: string[];
+    include?: string[];
+    nested?: PropertyQuery;
+}
+export interface PropertyQuery extends BaseQuery {
+    queryType: 'read';
+    scope: 'property';
+    operationType: 'read';
+    property: OpraSchema.Property;
+    nested?: PropertyQuery;
+}
+export interface UpdateQuery extends BaseQuery {
+    queryType: 'update';
+    scope: 'instance';
+    operationType: 'update';
+    resource: EntityResourceInfo;
+    keyValue: KeyValue;
+    data: {};
+    pick?: string[];
+    omit?: string[];
+    include?: string[];
+}
+export interface UpdateManyQuery extends BaseQuery {
+    queryType: 'updateMany';
+    scope: 'collection';
+    operationType: 'update';
+    resource: EntityResourceInfo;
+    filter?: string | Expression;
+    data: {};
+}
+export interface DeleteQuery extends BaseQuery {
+    queryType: 'delete';
+    scope: 'instance';
+    operationType: 'delete';
+    resource: EntityResourceInfo;
+    keyValue: KeyValue;
+}
+export interface DeleteManyQuery extends BaseQuery {
+    queryType: 'deleteMany';
+    scope: 'collection';
+    operationType: 'delete';
+    resource: EntityResourceInfo;
+    filter?: string | Expression;
+}
+export interface SearchQuery extends BaseQuery {
+    queryType: 'search';
+    scope: 'collection';
+    operationType: 'read';
+    resource: EntityResourceInfo;
+    pick?: string[];
+    omit?: string[];
+    include?: string[];
+    filter?: string | Expression;
+    limit?: number;
+    skip?: number;
+    distinct?: boolean;
+    total?: boolean;
+    sort?: string[];
+}
+export declare namespace ExecutionQuery {
+    function forCreate(resource: EntityResourceInfo, values: {}, options?: StrictOmit<CreateQuery, 'queryType' | 'scope' | 'operationType' | 'resource' | 'data'>): CreateQuery;
+    function forRead(resource: EntityResourceInfo, key: KeyValue, options?: StrictOmit<ReadQuery, 'queryType' | 'scope' | 'operationType' | 'resource' | 'keyValue'>): ReadQuery;
+    function forSearch(resource: EntityResourceInfo, options?: StrictOmit<SearchQuery, 'queryType' | 'scope' | 'operationType' | 'resource'>): SearchQuery;
+    function forProperty(property: OpraSchema.Property, options?: StrictOmit<PropertyQuery, 'queryType' | 'scope' | 'operationType' | 'property'>): PropertyQuery;
+    function forUpdate(resource: EntityResourceInfo, keyValue: KeyValue, values: any, options?: StrictOmit<UpdateQuery, 'queryType' | 'scope' | 'operationType' | 'resource' | 'keyValue' | 'data'>): UpdateQuery;
+    function forUpdateMany(resource: EntityResourceInfo, values: any, options?: StrictOmit<UpdateManyQuery, 'queryType' | 'scope' | 'operationType' | 'resource' | 'data'>): UpdateManyQuery;
+    function forDelete(resource: EntityResourceInfo, key: KeyValue): DeleteQuery;
+    function forDeleteMany(resource: EntityResourceInfo, options?: StrictOmit<DeleteManyQuery, 'queryType' | 'scope' | 'operationType' | 'resource'>): DeleteManyQuery;
+    function isCreateQuery(q: any): q is CreateQuery;
+    function isSearchQuery(q: any): q is SearchQuery;
+    function isReadQuery(q: any): q is ReadQuery;
+    function isDeleteQuery(q: any): q is DeleteQuery;
+}
+export {};

package/esm/interfaces/execution-query.interface.js

@@ -0,0 +1,186 @@
+import _ from 'lodash';
+import { ComplexType } from '../implementation/data-type/complex-type.js';
+import { stringPathToObjectTree } from '../utils/string-path-to-object-tree.js';
+export var ExecutionQuery;
+(function (ExecutionQuery) {
+    function forCreate(resource, values, options) {
+        if (options?.pick)
+            options.pick = normalizePick(resource, options.pick);
+        if (options?.omit)
+            options.omit = normalizePick(resource, options.omit);
+        if (options?.include)
+            options.include = normalizePick(resource, options.include);
+        const out = {
+            queryType: 'create',
+            scope: 'collection',
+            operationType: 'create',
+            resource,
+            data: values
+        };
+        Object.assign(out, _.omit(options, Object.keys(out)));
+        return out;
+    }
+    ExecutionQuery.forCreate = forCreate;
+    function forRead(resource, key, options) {
+        if (options?.pick)
+            options.pick = normalizePick(resource, options.pick);
+        if (options?.omit)
+            options.omit = normalizePick(resource, options.omit);
+        if (options?.include)
+            options.include = normalizePick(resource, options.include);
+        checkKeyFields(resource, key);
+        const out = {
+            queryType: 'read',
+            scope: 'instance',
+            operationType: 'read',
+            resource,
+            keyValue: key
+        };
+        Object.assign(out, _.omit(options, Object.keys(out)));
+        return out;
+    }
+    ExecutionQuery.forRead = forRead;
+    function forSearch(resource, options) {
+        if (options?.pick)
+            options.pick = normalizePick(resource, options.pick);
+        if (options?.omit)
+            options.omit = normalizePick(resource, options.omit);
+        if (options?.include)
+            options.include = normalizePick(resource, options.include);
+        if (options?.sort)
+            options.sort = normalizePick(resource, options.sort); // todo check allowed sort fields
+        const out = {
+            queryType: 'search',
+            scope: 'collection',
+            operationType: 'read',
+            resource
+        };
+        Object.assign(out, _.omit(options, Object.keys(out)));
+        return out;
+    }
+    ExecutionQuery.forSearch = forSearch;
+    function forProperty(property, options) {
+        const out = {
+            queryType: 'read',
+            scope: 'property',
+            operationType: 'read',
+            property
+        };
+        Object.assign(out, _.omit(options, Object.keys(out)));
+        return out;
+    }
+    ExecutionQuery.forProperty = forProperty;
+    function forUpdate(resource, keyValue, values, options) {
+        if (options?.pick)
+            options.pick = normalizePick(resource, options.pick);
+        if (options?.omit)
+            options.omit = normalizePick(resource, options.omit);
+        if (options?.include)
+            options.include = normalizePick(resource, options.include);
+        checkKeyFields(resource, keyValue);
+        const out = {
+            queryType: 'update',
+            scope: 'instance',
+            operationType: 'update',
+            resource,
+            keyValue,
+            data: values
+        };
+        Object.assign(out, _.omit(options, Object.keys(out)));
+        return out;
+    }
+    ExecutionQuery.forUpdate = forUpdate;
+    function forUpdateMany(resource, values, options) {
+        const out = {
+            queryType: 'updateMany',
+            scope: 'collection',
+            operationType: 'update',
+            resource,
+            data: values
+        };
+        Object.assign(out, _.omit(options, Object.keys(out)));
+        return out;
+    }
+    ExecutionQuery.forUpdateMany = forUpdateMany;
+    function forDelete(resource, key) {
+        checkKeyFields(resource, key);
+        return {
+            queryType: 'delete',
+            scope: 'instance',
+            operationType: 'delete',
+            resource,
+            keyValue: key
+        };
+    }
+    ExecutionQuery.forDelete = forDelete;
+    function forDeleteMany(resource, options) {
+        const out = {
+            queryType: 'deleteMany',
+            scope: 'collection',
+            operationType: 'delete',
+            resource,
+        };
+        Object.assign(out, _.omit(options, Object.keys(out)));
+        return out;
+    }
+    ExecutionQuery.forDeleteMany = forDeleteMany;
+    function isCreateQuery(q) {
+        return q && typeof q === 'object' && q.scope === 'collection' && q.queryType === 'create';
+    }
+    ExecutionQuery.isCreateQuery = isCreateQuery;
+    function isSearchQuery(q) {
+        return q && typeof q === 'object' && q.scope === 'collection' && q.queryType === 'search';
+    }
+    ExecutionQuery.isSearchQuery = isSearchQuery;
+    function isReadQuery(q) {
+        return q && typeof q === 'object' && q.scope === 'instance' && q.queryType === 'read';
+    }
+    ExecutionQuery.isReadQuery = isReadQuery;
+    function isDeleteQuery(q) {
+        return q && typeof q === 'object' && q.scope === 'instance' && q.queryType === 'delete';
+    }
+    ExecutionQuery.isDeleteQuery = isDeleteQuery;
+})(ExecutionQuery || (ExecutionQuery = {}));
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function checkKeyFields(resource, key) {
+    if (!resource.dataType.primaryKey)
+        throw new Error(`"${resource.name}" has no primary key`);
+}
+function normalizePick(resource, fields) {
+    const fieldsTree = stringPathToObjectTree(fields) || {};
+    return _normalizeFieldsList([], resource.service, resource, resource.dataType, fieldsTree, '', {
+        additionalProperties: true
+    });
+}
+function _normalizeFieldsList(target, service, resource, dataType, node, parentPath = '', options) {
+    let curPath = '';
+    for (const k of Object.keys(node)) {
+        const nodeVal = node[k];
+        const prop = dataType?.properties?.[k];
+        if (!prop) {
+            curPath = parentPath ? parentPath + '.' + k : k;
+            if (!options?.additionalProperties || (dataType && !dataType.additionalProperties))
+                throw new TypeError(`Unknown field path "${resource.name + '.' + curPath}"`);
+            if (typeof nodeVal === 'object')
+                _normalizeFieldsList(target, service, resource, undefined, nodeVal, curPath, options);
+            else
+                target.push(curPath);
+            continue;
+        }
+        curPath = parentPath ? parentPath + '.' + prop.name : prop.name;
+        const propType = service.getDataType(prop.type || 'string');
+        if (typeof nodeVal === 'object') {
+            if (!(propType instanceof ComplexType))
+                throw new TypeError(`"${curPath}" is not a complex type and has no sub fields`);
+            if (target.findIndex(x => x === parentPath) >= 0)
+                continue;
+            target = _normalizeFieldsList(target, service, resource, propType, nodeVal, curPath, options);
+            continue;
+        }
+        if (target.findIndex(x => x.startsWith(curPath + '.')) >= 0) {
+            target = target.filter(x => !x.startsWith(curPath + '.'));
+        }
+        target.push(curPath);
+    }
+    return target;
+}

package/esm/interfaces/http-context.interface.d.ts

@@ -0,0 +1,23 @@
+export interface IHttpAdapterContext {
+    getRequest(): IHttpRequest;
+    getResponse(): IHttpResponse;
+}
+export interface IHttpRequest {
+    getInstance(): any;
+    getUrl(): string;
+    getMethod(): string;
+    getHeaderNames(): string[];
+    getHeader(name: string): string | undefined;
+    getHeaders(): Record<string, any>;
+    getBody(): any;
+}
+export interface IHttpResponse {
+    getInstance(): any;
+    getStatus(): number | undefined;
+    setStatus(value: number): this;
+    getHeaderNames(name: string): string[];
+    getHeader(name: string): string | undefined;
+    setHeader(name: string, value: string): this;
+    send(body: any): this;
+    end(): this;
+}

package/esm/interfaces/http-context.interface.js

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

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

@@ -0,0 +1,14 @@
+import { StrictOmit } from 'ts-gems';
+import { OpraSchema } from '@opra/schema';
+import { TypeThunkAsync } from '../types.js';
+export declare type EntityResourceMetadata = StrictOmit<OpraSchema.EntityResource, 'type' | 'name'> & {
+    type: TypeThunkAsync | string;
+    name?: string;
+};
+export declare type ResourceReadOperationMetadata = StrictOmit<OpraSchema.ResourceReadOperation, 'handler'>;
+export declare type ResourceSearchOperationMetadata = StrictOmit<OpraSchema.ResourceSearchOperation, 'handler'>;
+export declare type ResourceCreateOperationMetadata = StrictOmit<OpraSchema.ResourceCreateOperation, 'handler'>;
+export declare type ResourceUpdateOperationMetadata = StrictOmit<OpraSchema.ResourceUpdateOperation, 'handler'>;
+export declare type ResourcePatchOperationMetadata = StrictOmit<OpraSchema.ResourcePatchOperation, 'handler'>;
+export declare type ResourceDeleteOperationMetadata = StrictOmit<OpraSchema.ResourceDeleteOperation, 'handler'>;
+export declare type ResourceExecuteOperationMetadata = StrictOmit<OpraSchema.ResourceExecuteOperation, 'handler'>;

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

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

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

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

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

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

package/esm/services/data-service.d.ts

@@ -0,0 +1,2 @@
+export declare abstract class DataService<T = any> {
+}

package/esm/services/data-service.js

@@ -0,0 +1,5 @@
+/* eslint-disable */
+// import { Type } from 'ts-gems';
+//  import { ComplexType } from '../implementation/data-type/complex-type.js';
+export class DataService {
+}

package/esm/services/json-data-service.d.ts

@@ -0,0 +1,9 @@
+import { DataService } from './data-service.js';
+export interface JsonDataServiceAgs {
+    data: any[];
+    primaryKey: string | string[];
+}
+export declare class JsonDataService extends DataService {
+    data: any[];
+    constructor(args: JsonDataServiceAgs);
+}

package/esm/services/json-data-service.js

@@ -0,0 +1,10 @@
+import ruleJudgment from 'rule-judgment';
+import { DataService } from './data-service.js';
+// Fix invalid importing (with ESM) of rule-judgment package
+const toArrayFilter = typeof ruleJudgment === 'function' ? ruleJudgment : ruleJudgment.default;
+export class JsonDataService extends DataService {
+    data;
+    constructor(args) {
+        super();
+    }
+}

package/esm/types.d.ts

@@ -0,0 +1,11 @@
+import type { DeepPartial, DeepPickJson, DeepPickWritable, Type } from 'ts-gems';
+export declare type Thunk<T> = T | (() => T);
+export declare type ThunkAsync<T> = T | Promise<T> | (() => T) | (() => Promise<T>);
+export declare type TypeThunk<T = any> = Thunk<Type<T>>;
+export declare type TypeThunkAsync<T = any> = ThunkAsync<Type<T>>;
+export declare type QueryScope = 'collection' | 'instance' | 'property';
+export declare type QueryType = 'create' | 'read' | 'update' | 'patch' | 'delete' | 'execute' | 'search' | 'updateMany' | 'patchMany' | 'deleteMany';
+export declare type OperationType = 'create' | 'read' | 'update' | 'patch' | 'delete' | 'execute';
+export declare type KeyValue = string | number | boolean | object;
+export declare type PartialInput<T> = DeepPartial<DeepPickWritable<DeepPickJson<T>>>;
+export declare type PartialOutput<T> = DeepPartial<DeepPickJson<T>>;

package/esm/types.js

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

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

@@ -0,0 +1,6 @@
+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

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