@goatlab/fluent 0.7.31 → 0.7.32

package/dist/core/Loopback/build-schema.js

@@ -1,333 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.modelToJsonSchema = exports.getNavigationalPropertyForRelation = exports.metaToJsonProperty = exports.isArrayType = exports.stringTypeToWrapper = exports.getJsonSchemaRef = exports.getJsonSchema = exports.buildModelCacheKey = exports.JSON_SCHEMA_KEY = void 0;
-const metadata_1 = require("@loopback/metadata");
-const util_1 = require("util");
-const type_resolver_1 = require("./type-resolver");
-const metadata_2 = require("./metadata");
-exports.JSON_SCHEMA_KEY = metadata_1.MetadataAccessor.create('loopback:json-schema');
-const debug = console.log;
-function buildModelCacheKey(options = {}) {
-    if (Object.keys(options).length === 0) {
-        return 'modelOnly';
-    }
-    return `model${options.title ?? ''}${getTitleSuffix(options)}`;
-}
-exports.buildModelCacheKey = buildModelCacheKey;
-function getJsonSchema(ctor, options) {
-    const cached = metadata_1.MetadataInspector.getClassMetadata(exports.JSON_SCHEMA_KEY, ctor, {
-        ownMetadataOnly: true
-    });
-    const key = buildModelCacheKey(options);
-    let schema = cached?.[key];
-    if (!schema) {
-        schema = modelToJsonSchema(ctor, options);
-        if (cached) {
-            cached[key] = schema;
-        }
-        else {
-            metadata_1.MetadataInspector.defineMetadata(exports.JSON_SCHEMA_KEY.key, { [key]: schema }, ctor);
-        }
-    }
-    return schema;
-}
-exports.getJsonSchema = getJsonSchema;
-function getJsonSchemaRef(modelCtor, options) {
-    const schemaWithDefinitions = getJsonSchema(modelCtor, options);
-    const key = schemaWithDefinitions.title;
-    if (!key)
-        return schemaWithDefinitions;
-    const definitions = { ...schemaWithDefinitions.definitions };
-    const schema = { ...schemaWithDefinitions };
-    delete schema.definitions;
-    definitions[key] = schema;
-    return {
-        $ref: `#/definitions/${key}`,
-        definitions
-    };
-}
-exports.getJsonSchemaRef = getJsonSchemaRef;
-function stringTypeToWrapper(type) {
-    if (typeof type === 'function') {
-        return type;
-    }
-    type = type.toLowerCase();
-    let wrapper;
-    switch (type) {
-        case 'number': {
-            wrapper = Number;
-            break;
-        }
-        case 'string': {
-            wrapper = String;
-            break;
-        }
-        case 'boolean': {
-            wrapper = Boolean;
-            break;
-        }
-        case 'array': {
-            wrapper = Array;
-            break;
-        }
-        case 'object':
-        case 'any': {
-            wrapper = Object;
-            break;
-        }
-        case 'date': {
-            wrapper = Date;
-            break;
-        }
-        case 'buffer': {
-            wrapper = Buffer;
-            break;
-        }
-        case 'null': {
-            wrapper = type_resolver_1.Null;
-            break;
-        }
-        default: {
-            throw new Error(`Unsupported type: ${type}`);
-        }
-    }
-    return wrapper;
-}
-exports.stringTypeToWrapper = stringTypeToWrapper;
-function isArrayType(type) {
-    return type === Array || type === 'array';
-}
-exports.isArrayType = isArrayType;
-function metaToJsonProperty(meta) {
-    const propDef = {};
-    let result;
-    let propertyType = meta.type;
-    if (isArrayType(propertyType) && meta.itemType) {
-        if (isArrayType(meta.itemType) && !meta.jsonSchema) {
-            throw new Error('You must provide the "jsonSchema" field when define ' +
-                'a nested array property');
-        }
-        result = { type: 'array', items: propDef };
-        propertyType = meta.itemType;
-    }
-    else {
-        result = propDef;
-    }
-    const wrappedType = stringTypeToWrapper(propertyType);
-    const resolvedType = (0, type_resolver_1.resolveType)(wrappedType);
-    if (resolvedType === Date) {
-        Object.assign(propDef, {
-            type: 'string',
-            format: 'date-time'
-        });
-    }
-    else if (propertyType === 'any') {
-    }
-    else if ((0, type_resolver_1.isBuiltinType)(resolvedType)) {
-        Object.assign(propDef, {
-            type: resolvedType.name.toLowerCase()
-        });
-    }
-    else {
-        Object.assign(propDef, { $ref: `#/definitions/${resolvedType.name}` });
-    }
-    if (meta.description) {
-        Object.assign(propDef, {
-            description: meta.description
-        });
-    }
-    if (meta.jsonSchema) {
-        Object.assign(propDef, meta.jsonSchema);
-    }
-    return result;
-}
-exports.metaToJsonProperty = metaToJsonProperty;
-function getNavigationalPropertyForRelation(relMeta, targetRef) {
-    if (relMeta.targetsMany === true) {
-        return {
-            type: 'array',
-            items: targetRef
-        };
-    }
-    if (relMeta.targetsMany === false) {
-        return targetRef;
-    }
-    throw new Error(`targetsMany attribute missing for ${relMeta.name}`);
-}
-exports.getNavigationalPropertyForRelation = getNavigationalPropertyForRelation;
-function buildSchemaTitle(ctor, meta, options) {
-    if (options.title)
-        return options.title;
-    const title = meta.title || ctor.name;
-    return title + getTitleSuffix(options);
-}
-function getTitleSuffix(options = {}) {
-    let suffix = '';
-    if (options.optional?.length) {
-        suffix += `Optional_${options.optional.join('-')}_`;
-    }
-    else if (options.partial) {
-        suffix += 'Partial';
-    }
-    if (options.exclude?.length) {
-        suffix += `Excluding_${options.exclude.join('-')}_`;
-    }
-    if (options.includeRelations) {
-        suffix += 'WithRelations';
-    }
-    return suffix;
-}
-function stringifyOptions(modelSettings = {}) {
-    return (0, util_1.inspect)(modelSettings, {
-        depth: Infinity,
-        maxArrayLength: Infinity,
-        breakLength: Infinity
-    });
-}
-function isEmptyJson(obj) {
-    return !(obj && Object.keys(obj).length);
-}
-function getDescriptionSuffix(typeName, rawOptions = {}) {
-    const options = { ...rawOptions };
-    delete options.visited;
-    if (options.optional && !options.optional.length) {
-        delete options.optional;
-    }
-    const type = typeName;
-    let tsType = type;
-    if (options.includeRelations) {
-        tsType = `${type}WithRelations`;
-    }
-    if (options.partial) {
-        tsType = `Partial<${tsType}>`;
-    }
-    if (options.exclude) {
-        const excludedProps = options.exclude.map(p => `'${p}'`);
-        tsType = `Omit<${tsType}, ${excludedProps.join(' | ')}>`;
-    }
-    if (options.optional) {
-        const optionalProps = options.optional.map(p => `'${p}'`);
-        tsType = `@loopback/repository-json-schema#Optional<${tsType}, ${optionalProps.join(' | ')}>`;
-    }
-    return !isEmptyJson(options)
-        ? `(tsType: ${tsType}, schemaOptions: ${stringifyOptions(options)})`
-        : '';
-}
-function modelToJsonSchema(ctor, jsonSchemaOptions = {}) {
-    const options = { ...jsonSchemaOptions };
-    options.visited = options.visited ?? {};
-    options.optional = options.optional ?? [];
-    const partial = options.partial && !options.optional.length;
-    if (options.partial && !partial) {
-        debug('Overriding "partial" option with "optional" option');
-        delete options.partial;
-    }
-    debug('Creating schema for model %s', ctor.name);
-    debug('JSON schema options: %o', options);
-    const modelDef = metadata_2.ModelMetadataHelper.getModelMetadata(ctor);
-    if (modelDef == null || Object.keys(modelDef).length === 0) {
-        return {};
-    }
-    const meta = modelDef;
-    debug('Model settings', meta.settings);
-    const title = buildSchemaTitle(ctor, meta, options);
-    if (options.visited[title])
-        return options.visited[title];
-    const result = { title };
-    options.visited[title] = result;
-    result.type = 'object';
-    const descriptionSuffix = getDescriptionSuffix(ctor.name, options);
-    if (meta.description) {
-        const formatSuffix = descriptionSuffix ? ` ${descriptionSuffix}` : '';
-        result.description = meta.description + formatSuffix;
-    }
-    else if (descriptionSuffix) {
-        result.description = descriptionSuffix;
-    }
-    for (const p in meta.properties) {
-        if (options.exclude?.includes(p)) {
-            debug('Property % is excluded by %s', p, options.exclude);
-            continue;
-        }
-        if (meta.properties[p].type == null) {
-            throw new Error(`Property ${ctor.name}.${p} does not have "type" in its definition`);
-        }
-        result.properties = result.properties ?? {};
-        result.properties[p] = result.properties[p] || {};
-        const metaProperty = { ...meta.properties[p] };
-        result.properties[p] = metaToJsonProperty(metaProperty);
-        const optional = options.optional.includes(p);
-        if (metaProperty.required && !(partial || optional)) {
-            result.required = result.required ?? [];
-            result.required.push(p);
-        }
-        const resolvedType = (0, type_resolver_1.resolveType)(metaProperty.type);
-        const referenceType = isArrayType(resolvedType)
-            ?
-                (0, type_resolver_1.resolveType)(metaProperty.itemType)
-            : resolvedType;
-        if (typeof referenceType !== 'function' || (0, type_resolver_1.isBuiltinType)(referenceType)) {
-            continue;
-        }
-        const propOptions = { ...options };
-        if (propOptions.partial !== 'deep') {
-            delete propOptions.partial;
-        }
-        if (propOptions.includeRelations === true) {
-            delete propOptions.includeRelations;
-        }
-        delete propOptions.title;
-        const propSchema = getJsonSchema(referenceType, propOptions);
-        if (typeof result.properties[p] !== 'boolean') {
-            const prop = result.properties[p];
-            const propTitle = propSchema.title ?? referenceType.name;
-            const targetRef = { $ref: `#/definitions/${propTitle}` };
-            if (prop.type === 'array' && prop.items) {
-                prop.items = targetRef;
-            }
-            else {
-                result.properties[p] = targetRef;
-            }
-            includeReferencedSchema(propTitle, propSchema);
-        }
-    }
-    result.additionalProperties = meta.settings.strict === false;
-    debug('  additionalProperties?', result.additionalProperties);
-    if (options.includeRelations) {
-        for (const r in meta.relations) {
-            result.properties = result.properties ?? {};
-            const relMeta = meta.relations[r];
-            const targetType = (0, type_resolver_1.resolveType)(relMeta.target);
-            const targetOptions = { ...options };
-            delete targetOptions.title;
-            const targetSchema = getJsonSchema(targetType, targetOptions);
-            const targetRef = { $ref: `#/definitions/${targetSchema.title}` };
-            const propDef = getNavigationalPropertyForRelation(relMeta, targetRef);
-            result.properties[relMeta.name] =
-                result.properties[relMeta.name] || propDef;
-            includeReferencedSchema(targetSchema.title, targetSchema);
-        }
-    }
-    function includeReferencedSchema(name, schema) {
-        if (!schema || !Object.keys(schema).length)
-            return;
-        if (result !== schema?.definitions) {
-            for (const key in schema.definitions) {
-                if (key === title)
-                    continue;
-                result.definitions = result.definitions ?? {};
-                result.definitions[key] = schema.definitions[key];
-            }
-            delete schema.definitions;
-        }
-        if (result !== schema) {
-            result.definitions = result.definitions ?? {};
-            result.definitions[name] = schema;
-        }
-    }
-    if (meta.jsonSchema) {
-        Object.assign(result, meta.jsonSchema);
-    }
-    return result;
-}
-exports.modelToJsonSchema = modelToJsonSchema;

package/dist/core/Loopback/common-types.d.ts

@@ -1,36 +0,0 @@
-export interface Class<T> {
-    new (...args: any[]): T;
-    [property: string]: any;
-}
-export interface ConstructorFunction<T> {
-    (...args: any[]): T;
-}
-export declare type Constructor<T> = Class<T> | ConstructorFunction<T>;
-export interface AnyObject {
-    [property: string]: any;
-}
-export declare type DeepPartial<T> = Partial<T> | {
-    [P in keyof T]?: DeepPartial<T[P]>;
-};
-export declare type DataObject<T extends object> = T | DeepPartial<T>;
-export declare type Options = AnyObject;
-export declare type Callback<T> = (err: Error | string | null | undefined, result?: T) => void;
-export declare type Command = string | AnyObject;
-export declare type NamedParameters = AnyObject;
-export declare type PositionalParameters = any[];
-export interface Count {
-    count: number;
-}
-export declare const CountSchema: {
-    type: "object";
-    title: string;
-    'x-typescript-type': string;
-    properties: {
-        count: {
-            type: "number";
-        };
-    };
-};
-export declare type PrototypeOf<Ctor extends Function> = Ctor extends {
-    prototype: infer Proto;
-} ? Proto : never;

package/dist/core/Loopback/common-types.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CountSchema = void 0;
-exports.CountSchema = {
-    type: 'object',
-    title: 'loopback.Count',
-    'x-typescript-type': '@loopback/repository#Count',
-    properties: {
-        count: {
-            type: 'number'
-        }
-    }
-};

package/dist/core/Loopback/json-to-schema.d.ts

@@ -1,6 +0,0 @@
-import { ReferenceObject, SchemaObject, SchemasObject } from 'openapi3-ts';
-export declare type SchemaRef = ReferenceObject & {
-    definitions: SchemasObject;
-};
-export declare function jsonToSchemaObject(json: SchemaObject, visited?: Map<SchemaObject, SchemaObject | SchemaRef>): SchemaObject | SchemaRef;
-export declare function jsonOrBooleanToJSON(jsonOrBool: boolean | SchemaObject): SchemaObject;

package/dist/core/Loopback/json-to-schema.js

@@ -1,96 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.jsonOrBooleanToJSON = exports.jsonToSchemaObject = void 0;
-const tslib_1 = require("tslib");
-const mapValues_1 = tslib_1.__importDefault(require("./mapValues"));
-const openapi3_ts_1 = require("openapi3-ts");
-function jsonToSchemaObject(json, visited = new Map()) {
-    const converted = 'x-loopback-converted';
-    const schema = visited.get(json);
-    if (schema != null && (0, openapi3_ts_1.isSchemaObject)(schema) && schema[converted] === false) {
-        return { $ref: `#/components/schemas/${json.title}` };
-    }
-    if (schema != null)
-        return schema;
-    const result = {
-        [converted]: false
-    };
-    visited.set(json, result);
-    const propsToIgnore = ['additionalItems', 'defaultProperties', 'typeof'];
-    for (const property in json) {
-        if (propsToIgnore.includes(property)) {
-            continue;
-        }
-        switch (property) {
-            case 'type': {
-                if (json.type === 'array' && !json.items) {
-                    throw new Error('"items" property must be present if "type" is an array');
-                }
-                result.type = Array.isArray(json.type) ? json.type[0] : json.type;
-                break;
-            }
-            case 'allOf': {
-                result.allOf = json.allOf?.map(item => jsonToSchemaObject(item, visited));
-                break;
-            }
-            case 'anyOf': {
-                result.anyOf = json.anyOf?.map(item => jsonToSchemaObject(item, visited));
-                break;
-            }
-            case 'oneOf': {
-                result.oneOf = json.oneOf?.map(item => jsonToSchemaObject(item, visited));
-                break;
-            }
-            case 'definitions': {
-                result.definitions = (0, mapValues_1.default)(json.definitions, def => jsonToSchemaObject(jsonOrBooleanToJSON(def), visited));
-                break;
-            }
-            case 'properties': {
-                result.properties = (0, mapValues_1.default)(json.properties, item => jsonToSchemaObject(jsonOrBooleanToJSON(item), visited));
-                break;
-            }
-            case 'additionalProperties': {
-                if (typeof json.additionalProperties === 'boolean') {
-                    result.additionalProperties = json.additionalProperties;
-                }
-                else {
-                    result.additionalProperties = jsonToSchemaObject(json.additionalProperties, visited);
-                }
-                break;
-            }
-            case 'items': {
-                const items = Array.isArray(json.items) ? json.items[0] : json.items;
-                result.items = jsonToSchemaObject(jsonOrBooleanToJSON(items), visited);
-                break;
-            }
-            case '$ref': {
-                result.$ref = json.$ref.replace('#/definitions', '#/components/schemas');
-                break;
-            }
-            case 'examples': {
-                if (Array.isArray(json.examples)) {
-                    result.example = json.examples[0];
-                }
-                break;
-            }
-            default: {
-                result[property] = json[property];
-                break;
-            }
-        }
-    }
-    delete result[converted];
-    const matched = result.description?.match(/^\(tsType: (.+), schemaOptions:/);
-    if (matched) {
-        result['x-typescript-type'] = matched[1];
-    }
-    return result;
-}
-exports.jsonToSchemaObject = jsonToSchemaObject;
-function jsonOrBooleanToJSON(jsonOrBool) {
-    if (typeof jsonOrBool === 'object') {
-        return jsonOrBool;
-    }
-    return jsonOrBool ? {} : { not: {} };
-}
-exports.jsonOrBooleanToJSON = jsonOrBooleanToJSON;

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

@@ -1,2 +0,0 @@
-export = mapValues;
-declare function mapValues(object: any, iteratee?: Function | undefined): any;