@goatlab/fluent 0.7.31 → 0.7.33

package/dist/core/Loopback/metadata.d.ts

@@ -1,9 +0,0 @@
-import { InspectionOptions, MetadataAccessor, MetadataMap } from '@loopback/metadata';
-import { ModelDefinition, ModelDefinitionSyntax, PropertyDefinition } from './model';
-export declare const MODEL_KEY: MetadataAccessor<Partial<ModelDefinitionSyntax>, ClassDecorator>;
-export declare const MODEL_PROPERTIES_KEY: MetadataAccessor<PropertyDefinition, PropertyDecorator>;
-export declare const MODEL_WITH_PROPERTIES_KEY: MetadataAccessor<ModelDefinition, ClassDecorator>;
-export declare type PropertyMap = MetadataMap<Partial<PropertyDefinition>>;
-export declare class ModelMetadataHelper {
-    static getModelMetadata(target: Function, options?: InspectionOptions): ModelDefinition | {};
-}

package/dist/core/Loopback/metadata.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ModelMetadataHelper = exports.MODEL_WITH_PROPERTIES_KEY = exports.MODEL_PROPERTIES_KEY = exports.MODEL_KEY = void 0;
-const metadata_1 = require("@loopback/metadata");
-const model_1 = require("./model");
-const RELATIONS_KEY = 'loopback:relations';
-exports.MODEL_KEY = metadata_1.MetadataAccessor.create('loopback:model');
-exports.MODEL_PROPERTIES_KEY = metadata_1.MetadataAccessor.create('loopback:model-properties');
-exports.MODEL_WITH_PROPERTIES_KEY = metadata_1.MetadataAccessor.create('loopback:model-and-properties');
-class ModelMetadataHelper {
-    static getModelMetadata(target, options) {
-        const classDef = metadata_1.MetadataInspector.getClassMetadata(exports.MODEL_WITH_PROPERTIES_KEY, target, { ...options, ownMetadataOnly: true });
-        if (classDef) {
-            return classDef;
-        }
-        const modelMeta = metadata_1.MetadataInspector.getClassMetadata(exports.MODEL_KEY, target, options);
-        if (!modelMeta) {
-            return {};
-        }
-        const meta = new model_1.ModelDefinition({ ...modelMeta });
-        Object.assign(meta, modelMeta);
-        meta.properties = Object.assign(meta.properties, metadata_1.MetadataInspector.getAllPropertyMetadata(exports.MODEL_PROPERTIES_KEY, target.prototype, options));
-        meta.relations = Object.assign(meta.relations, metadata_1.MetadataInspector.getAllPropertyMetadata(RELATIONS_KEY, target.prototype, options));
-        metadata_1.MetadataInspector.defineMetadata(exports.MODEL_WITH_PROPERTIES_KEY.key, meta, target);
-        return meta;
-    }
-}
-exports.ModelMetadataHelper = ModelMetadataHelper;

package/dist/core/Loopback/model.d.ts

@@ -1,87 +0,0 @@
-import { SchemaObject as JsonSchema } from 'openapi3-ts';
-import { AnyObject, DataObject, Options, PrototypeOf } from './common-types';
-import { BelongsToDefinition, HasManyDefinition, HasOneDefinition, RelationMetadata } from './relation.types';
-import { TypeResolver } from './type-resolver';
-import { Type } from './type';
-export interface JsonSchemaWithExtensions extends JsonSchema {
-    [attributes: string]: any;
-}
-export declare type PropertyType = string | Function | object | Type<any> | TypeResolver<Model>;
-export interface PropertyDefinition {
-    type: PropertyType;
-    id?: boolean | number;
-    hidden?: boolean;
-    json?: PropertyForm;
-    jsonSchema?: JsonSchemaWithExtensions;
-    store?: PropertyForm;
-    itemType?: PropertyType;
-    [attribute: string]: any;
-}
-export interface ModelSettings {
-    description?: string;
-    forceId?: boolean;
-    hiddenProperties?: string[];
-    scope?: object;
-    strict?: boolean | 'filter';
-    [name: string]: any;
-}
-export interface PropertyForm {
-    in?: boolean;
-    out?: boolean;
-    name?: string;
-}
-export declare type RelationDefinitionMap = {
-    [relationName: string]: RelationMetadata;
-};
-export interface ModelDefinitionSyntax {
-    name: string;
-    properties?: {
-        [name: string]: PropertyDefinition | PropertyType;
-    };
-    settings?: ModelSettings;
-    relations?: RelationDefinitionMap;
-    jsonSchema?: JsonSchemaWithExtensions;
-    [attribute: string]: any;
-}
-export declare class ModelDefinition {
-    readonly name: string;
-    properties: {
-        [name: string]: PropertyDefinition;
-    };
-    settings: ModelSettings;
-    relations: RelationDefinitionMap;
-    [attribute: string]: any;
-    constructor(nameOrDef: string | ModelDefinitionSyntax);
-    addProperty(name: string, definitionOrType: PropertyDefinition | PropertyType): this;
-    addSetting(name: string, value: any): this;
-    addRelation(definition: RelationMetadata): this;
-    belongsTo(name: string, definition: Omit<BelongsToDefinition, 'name' | 'type' | 'targetsMany'>): this;
-    hasOne(name: string, definition: Omit<HasOneDefinition, 'name' | 'type' | 'targetsMany'>): this;
-    hasMany(name: string, definition: Omit<HasManyDefinition, 'name' | 'type' | 'targetsMany'>): this;
-    idProperties(): string[];
-}
-export declare class Model {
-    static get modelName(): string;
-    static definition: ModelDefinition;
-    toJSON(): Object;
-    toObject(options?: Options): Object;
-    constructor(data?: DataObject<Model>);
-}
-export interface Persistable {
-}
-export declare abstract class ValueObject extends Model implements Persistable {
-}
-export declare class Entity extends Model implements Persistable {
-    static getIdProperties(): string[];
-    static getIdOf(entityOrData: AnyObject): any;
-    getId(): any;
-    getIdObject(): Object;
-    static buildWhereForId(id: any): any;
-}
-export declare class Event {
-    source: any;
-    type: string;
-}
-export declare type EntityData = DataObject<Entity>;
-export declare type EntityResolver<T extends Entity> = TypeResolver<T, typeof Entity>;
-export declare function rejectNavigationalPropertiesInData<M extends typeof Entity>(modelClass: M, data: DataObject<PrototypeOf<M>>): void;

package/dist/core/Loopback/model.js

@@ -1,244 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.rejectNavigationalPropertiesInData = exports.Event = exports.Entity = exports.ValueObject = exports.Model = exports.ModelDefinition = void 0;
-const relation_types_1 = require("./relation.types");
-class ModelDefinition {
-    constructor(nameOrDef) {
-        if (typeof nameOrDef === 'string') {
-            nameOrDef = { name: nameOrDef };
-        }
-        const { name, properties, settings, relations } = nameOrDef;
-        this.name = name;
-        this.properties = {};
-        if (properties) {
-            for (const p in properties) {
-                this.addProperty(p, properties[p]);
-            }
-        }
-        this.settings = settings ?? new Map();
-        this.relations = relations ?? {};
-    }
-    addProperty(name, definitionOrType) {
-        const definition = definitionOrType.type
-            ? definitionOrType
-            : { type: definitionOrType };
-        if (definition.id === true &&
-            definition.generated === true &&
-            definition.type !== undefined &&
-            definition.useDefaultIdType === undefined) {
-            definition.useDefaultIdType = false;
-        }
-        this.properties[name] = definition;
-        return this;
-    }
-    addSetting(name, value) {
-        this.settings[name] = value;
-        return this;
-    }
-    addRelation(definition) {
-        this.relations[definition.name] = definition;
-        return this;
-    }
-    belongsTo(name, definition) {
-        const meta = {
-            ...definition,
-            name,
-            type: relation_types_1.RelationType.belongsTo,
-            targetsMany: false
-        };
-        return this.addRelation(meta);
-    }
-    hasOne(name, definition) {
-        const meta = {
-            ...definition,
-            name,
-            type: relation_types_1.RelationType.hasOne,
-            targetsMany: false
-        };
-        return this.addRelation(meta);
-    }
-    hasMany(name, definition) {
-        const meta = {
-            ...definition,
-            name,
-            type: relation_types_1.RelationType.hasMany,
-            targetsMany: true
-        };
-        return this.addRelation(meta);
-    }
-    idProperties() {
-        if (typeof this.settings.id === 'string') {
-            return [this.settings.id];
-        }
-        if (Array.isArray(this.settings.id)) {
-            return this.settings.id;
-        }
-        const idProps = Object.keys(this.properties).filter(prop => this.properties[prop].id);
-        return idProps;
-    }
-}
-exports.ModelDefinition = ModelDefinition;
-function asJSON(value) {
-    if (value == null)
-        return value;
-    if (typeof value.toJSON === 'function') {
-        return value.toJSON();
-    }
-    if (Array.isArray(value)) {
-        return value.map(item => asJSON(item));
-    }
-    return value;
-}
-function asObject(value, options) {
-    if (value == null)
-        return value;
-    if (typeof value.toObject === 'function') {
-        return value.toObject(options);
-    }
-    if (Array.isArray(value)) {
-        return value.map(item => asObject(item, options));
-    }
-    return value;
-}
-class Model {
-    constructor(data) {
-        Object.assign(this, data);
-    }
-    static get modelName() {
-        return this.definition?.name || this.name;
-    }
-    toJSON() {
-        const def = this.constructor.definition;
-        if (def == null || def.settings.strict === false) {
-            return this.toObject({ ignoreUnknownProperties: false });
-        }
-        const copyPropertyAsJson = (key) => {
-            const val = asJSON(this[key]);
-            if (val !== undefined) {
-                json[key] = val;
-            }
-        };
-        const json = {};
-        const hiddenProperties = def.settings.hiddenProperties || [];
-        for (const p in def.properties) {
-            if (p in this && !hiddenProperties.includes(p)) {
-                copyPropertyAsJson(p);
-            }
-        }
-        for (const r in def.relations) {
-            const relName = def.relations[r].name;
-            if (relName in this) {
-                copyPropertyAsJson(relName);
-            }
-        }
-        return json;
-    }
-    toObject(options) {
-        const def = this.constructor.definition;
-        const obj = {};
-        if (options?.ignoreUnknownProperties === false) {
-            const hiddenProperties = def?.settings.hiddenProperties || [];
-            for (const p in this) {
-                if (!hiddenProperties.includes(p)) {
-                    const val = this[p];
-                    obj[p] = asObject(val, options);
-                }
-            }
-            return obj;
-        }
-        if (def?.relations) {
-            for (const r in def.relations) {
-                const relName = def.relations[r].name;
-                if (relName in this) {
-                    obj[relName] = asObject(this[relName], {
-                        ...options,
-                        ignoreUnknownProperties: false
-                    });
-                }
-            }
-        }
-        const props = def.properties;
-        const keys = Object.keys(props);
-        for (const i in keys) {
-            const propertyName = keys[i];
-            const val = this[propertyName];
-            if (val === undefined)
-                continue;
-            obj[propertyName] = asObject(val, options);
-        }
-        return obj;
-    }
-}
-exports.Model = Model;
-class ValueObject extends Model {
-}
-exports.ValueObject = ValueObject;
-class Entity extends Model {
-    static getIdProperties() {
-        return this.definition.idProperties();
-    }
-    static getIdOf(entityOrData) {
-        if (typeof entityOrData.getId === 'function') {
-            return entityOrData.getId();
-        }
-        const idName = this.getIdProperties()[0];
-        return entityOrData[idName];
-    }
-    getId() {
-        const { definition } = this.constructor;
-        const idProps = definition.idProperties();
-        if (idProps.length === 1) {
-            return this[idProps[0]];
-        }
-        if (!idProps.length) {
-            throw new Error(`Invalid Entity ${this.constructor.name}:` +
-                'missing primary key (id) property');
-        }
-        return this.getIdObject();
-    }
-    getIdObject() {
-        const { definition } = this.constructor;
-        const idProps = definition.idProperties();
-        const idObj = {};
-        for (const idProp of idProps) {
-            idObj[idProp] = this[idProp];
-        }
-        return idObj;
-    }
-    static buildWhereForId(id) {
-        const where = {};
-        const idProps = this.definition.idProperties();
-        if (idProps.length === 1) {
-            where[idProps[0]] = id;
-        }
-        else {
-            for (const idProp of idProps) {
-                where[idProp] = id[idProp];
-            }
-        }
-        return where;
-    }
-}
-exports.Entity = Entity;
-class Event {
-}
-exports.Event = Event;
-function rejectNavigationalPropertiesInData(modelClass, data) {
-    const def = modelClass.definition;
-    const props = def.properties;
-    for (const r in def.relations) {
-        const relName = def.relations[r].name;
-        if (!(relName in data))
-            continue;
-        let msg = 'Navigational properties are not allowed in model data ' +
-            `(model "${modelClass.modelName}" property "${relName}"), ` +
-            'please remove it.';
-        if (relName in props) {
-            msg +=
-                ' The error might be invoked by belongsTo relations, please make' +
-                    ' sure the relation name is not the same as the property name.';
-        }
-        throw new Error(msg);
-    }
-}
-exports.rejectNavigationalPropertiesInData = rejectNavigationalPropertiesInData;

package/dist/core/Loopback/query.d.ts

@@ -1,97 +0,0 @@
-declare type AnyObject = Record<string, any>;
-export declare type Operators = 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'inq' | 'nin' | 'between' | 'exists' | 'and' | 'or' | 'like' | 'nlike' | 'ilike' | 'nilike' | 'regexp';
-export declare type PredicateComparison<PT> = {
-    eq?: PT;
-    neq?: PT;
-    gt?: PT;
-    gte?: PT;
-    lt?: PT;
-    lte?: PT;
-    inq?: PT[];
-    nin?: PT[];
-    between?: [PT, PT];
-    exists?: boolean;
-    like?: PT;
-    nlike?: PT;
-    ilike?: PT;
-    nilike?: PT;
-    regexp?: string | RegExp;
-};
-export declare type ShortHandEqualType = string | number | boolean | Date;
-export declare type KeyOf<MT extends object> = Exclude<Extract<keyof MT, string>, Operators>;
-export declare type Condition<MT extends object> = {
-    [P in KeyOf<MT>]?: PredicateComparison<MT[P]> | (MT[P] & ShortHandEqualType);
-};
-export declare type Where<MT extends object = AnyObject> = Condition<MT> | AndClause<MT> | OrClause<MT>;
-export interface AndClause<MT extends object> {
-    and: Where<MT>[];
-}
-export interface OrClause<MT extends object> {
-    or: Where<MT>[];
-}
-export declare type Direction = 'ASC' | 'DESC';
-export declare type Order<MT = AnyObject> = {
-    [P in keyof MT]: Direction;
-};
-export declare type Fields<MT = AnyObject> = {
-    [P in keyof MT]?: boolean;
-} | Extract<keyof MT, string>[];
-export interface Inclusion {
-    relation: string;
-    scope?: Filter<AnyObject> & {
-        totalLimit?: number;
-    };
-}
-export interface Filter<MT extends object = AnyObject> {
-    where?: Where<MT>;
-    fields?: Fields<MT>;
-    order?: string[];
-    limit?: number;
-    skip?: number;
-    offset?: number;
-    include?: InclusionFilter[];
-}
-export declare type InclusionFilter = string | Inclusion;
-export declare type FilterExcludingWhere<MT extends object = AnyObject> = Omit<Filter<MT>, 'where'>;
-export declare function isFilter<MT extends object>(candidate: any): candidate is Filter<MT>;
-export declare class WhereBuilder<MT extends object = AnyObject> {
-    where: Where<MT>;
-    constructor(w?: Where<MT>);
-    private add;
-    cast(clause: AndClause<MT> | OrClause<MT> | Condition<MT>): Where<MT>;
-    and(...w: (Where<MT> | Where<MT>[])[]): this;
-    or(...w: (Where<MT> | Where<MT>[])[]): this;
-    eq<K extends KeyOf<MT>>(key: K, val: MT[K]): this;
-    neq<K extends KeyOf<MT>>(key: K, val: MT[K]): this;
-    gt<K extends KeyOf<MT>>(key: K, val: MT[K]): this;
-    gte<K extends KeyOf<MT>>(key: K, val: MT[K]): this;
-    lt<K extends KeyOf<MT>>(key: K, val: MT[K]): this;
-    lte<K extends KeyOf<MT>>(key: K, val: MT[K]): this;
-    inq<K extends KeyOf<MT>>(key: K, val: MT[K][]): this;
-    nin<K extends KeyOf<MT>>(key: K, val: MT[K][]): this;
-    between<K extends KeyOf<MT>>(key: K, val1: MT[K], val2: MT[K]): this;
-    exists<K extends KeyOf<MT>>(key: K, val?: boolean): this;
-    impose(where: Where<MT>): this;
-    like<K extends KeyOf<MT>>(key: K, val: MT[K]): this;
-    nlike<K extends KeyOf<MT>>(key: K, val: MT[K]): this;
-    ilike<K extends KeyOf<MT>>(key: K, val: MT[K]): this;
-    nilike<K extends KeyOf<MT>>(key: K, val: MT[K]): this;
-    regexp<K extends KeyOf<MT>>(key: K, val: string | RegExp): this;
-    build(): Where<MT>;
-}
-export declare class FilterBuilder<MT extends object = AnyObject> {
-    filter: Filter<MT>;
-    constructor(f?: Filter<MT>);
-    limit(limit: number): this;
-    offset(offset: number): this;
-    skip(skip: number): this;
-    fields(...f: (Fields<MT> | Extract<keyof MT, string>)[]): this;
-    private validateOrder;
-    order(...o: (string | string[] | Order<MT>)[]): this;
-    include(...i: (string | string[] | Inclusion)[]): this;
-    where(w: Where<MT>): this;
-    impose(constraint: Filter<MT> | Where<MT>): this;
-    build(): Filter<MT>;
-}
-export declare function filterTemplate(strings: TemplateStringsArray, ...keys: any[]): (ctx: AnyObject) => any;
-export {};