@goatlab/fluent 0.7.21 → 0.7.22

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

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

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

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

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

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

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