@cparra/apexdocs 2.23.0 → 2.24.0

package/lib/transpiler/openapi/parsers/ReferenceBuilder.js

@@ -1,226 +1,226 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ReferenceBuilder = void 0;
-const yaml = require("js-yaml");
-const types_repository_1 = require("../../../model/types-repository");
-class ReferenceBuilder {
-    constructor() {
-        this.isReferenceString = (targetObject) => {
-            return typeof targetObject === 'string' || targetObject instanceof String;
-        };
-    }
-    build(referencedTypeName) {
-        const originalTypeName = referencedTypeName;
-        // Checking for inline overrides of the type: [memberName:ClassOverrideName]
-        const regexForSchemaOverrides = /\[(.*?)]/g;
-        const schemaOverrides = referencedTypeName.match(regexForSchemaOverrides);
-        let referenceOverrides = [];
-        if (schemaOverrides && schemaOverrides.length > 0) {
-            referenceOverrides = ReferenceOverrides.build(schemaOverrides[0]);
-            referencedTypeName = referencedTypeName.replace(regexForSchemaOverrides, '');
-        }
-        const [parsedReferencedType, isCollection] = this.handlePossibleCollectionReference(referencedTypeName);
-        const referencedTypeBundle = types_repository_1.TypesRepository.getInstance().getFromAllByName(parsedReferencedType);
-        if (!referencedTypeBundle) {
-            throw new Error(`The referenced type ${referencedTypeName} was not found.`);
-        }
-        if (referencedTypeBundle.type.type_name !== 'class') {
-            throw new Error(`Expected the referenced type to be a class, but found a ${referencedTypeBundle.type.type_name}.`);
-        }
-        const typeBundleWithIsCollection = Object.assign(Object.assign({}, referencedTypeBundle), { originalTypeName: originalTypeName, isCollection: isCollection, referenceOverrides: referenceOverrides });
-        return this.buildReferenceFromType(typeBundleWithIsCollection);
-    }
-    /**
-     * Returns a tuple where the first value is the name of the reference without any collection related values
-     * and the second is a boolean representing if we are dealing with a collection or not.
-     * @param referencedTypeName The received raw type name.
-     * @private
-     */
-    handlePossibleCollectionReference(referencedTypeName) {
-        referencedTypeName = referencedTypeName.toLowerCase();
-        if (referencedTypeName.startsWith('list<') && referencedTypeName.endsWith('>')) {
-            referencedTypeName = referencedTypeName.replace('list<', '');
-            referencedTypeName = referencedTypeName.replace('>', '');
-            return [referencedTypeName, true];
-        }
-        if (referencedTypeName.startsWith('set<') && referencedTypeName.endsWith('>')) {
-            referencedTypeName = referencedTypeName.replace('set<', '');
-            referencedTypeName = referencedTypeName.replace('>', '');
-            return [referencedTypeName, true];
-        }
-        return [referencedTypeName, false];
-    }
-    buildReferenceFromType(typeBundle) {
-        // Filtering based on Salesforce's documentation:
-        // https://developer.salesforce.com/docs/atlas.en-us.apexcode.meta/apexcode/apex_rest_methods.htm#ApexRESTUserDefinedTypes
-        // We assume that the class only contains object types allowed by Apex Rest:
-        // "Note that the public, private, or global class member variables must be types allowed by Apex REST"
-        const propertiesAndFields = [
-            ...typeBundle.type.properties,
-            ...typeBundle.type.fields,
-        ]
-            .filter((current) => !current.memberModifiers.includes('static'))
-            .filter((current) => !current.memberModifiers.includes('transient'));
-        const properties = {};
-        let referencedComponents = [];
-        propertiesAndFields.forEach((current) => {
-            var _a, _b;
-            // Check if there are reference overrides for the current property, this takes priority over anything else.
-            const referenceOverride = typeBundle.referenceOverrides.find((currentOverride) => {
-                return currentOverride.propertyName.toLowerCase() === current.name.toLowerCase();
-            });
-            if (referenceOverride) {
-                const reference = this.build(referenceOverride.referenceName);
-                properties[current.name] = reference.entrypointReferenceObject;
-                reference.referenceComponents.forEach((current) => referencedComponents.push(current));
-            }
-            else {
-                // Check for "@http-schema" annotations within properties themselves. If these are specified they
-                // take precedence over the property type itself.
-                const manuallyDefinedHttpSchema = (_a = current.docComment) === null || _a === void 0 ? void 0 : _a.annotations.find((annotation) => annotation.name.toLowerCase() === 'http-schema');
-                if (manuallyDefinedHttpSchema) {
-                    this.handleOverriddenSchema(manuallyDefinedHttpSchema, properties, current, referencedComponents);
-                }
-                else {
-                    const pair = this.getReferenceType(current.typeReference);
-                    properties[current.name] = pair.schema;
-                    referencedComponents.push(...pair.referenceComponents);
-                }
-            }
-            properties[current.name].description = (_b = current.docComment) === null || _b === void 0 ? void 0 : _b.description;
-        });
-        const mainReferenceComponents = this.buildMainReferenceComponent(typeBundle, properties);
-        // Make sure to add the "main" reference first
-        referencedComponents = [...mainReferenceComponents, ...referencedComponents];
-        return {
-            entrypointReferenceObject: {
-                $ref: `#/components/schemas/${this.getReferenceName(typeBundle)}`,
-            },
-            referenceComponents: referencedComponents,
-        };
-    }
-    handleOverriddenSchema(manuallyDefinedHttpSchema, properties, current, referencedComponents) {
-        // This can be of type ApexDocSchemaObject
-        const inYaml = manuallyDefinedHttpSchema === null || manuallyDefinedHttpSchema === void 0 ? void 0 : manuallyDefinedHttpSchema.bodyLines.reduce((prev, current, _) => prev + '\n' + current);
-        const asJson = yaml.load(inYaml);
-        const isReferenceString = this.isReferenceString(asJson);
-        if (isReferenceString) {
-            const reference = this.build(asJson);
-            properties[current.name] = reference.entrypointReferenceObject;
-            reference.referenceComponents.forEach((current) => referencedComponents.push(current));
-        }
-        else {
-            // If we are dealing with a manually defined schema object, we can add it directly to the "properties" map,
-            // because we don't need to add a reference component.
-            properties[current.name] = asJson;
-        }
-    }
-    getReferenceName(typeBundle) {
-        var _a;
-        let referenceName = typeBundle.type.name;
-        if (typeBundle.isChild) {
-            referenceName = `${(_a = typeBundle.parentType) === null || _a === void 0 ? void 0 : _a.name}.${typeBundle.type.name}`;
-        }
-        if (typeBundle.isCollection) {
-            referenceName = `${referenceName}_array`;
-        }
-        if (typeBundle.referenceOverrides.length) {
-            referenceName = `${referenceName}_${typeBundle.originalTypeName}`;
-        }
-        return referenceName;
-    }
-    buildMainReferenceComponent(typeBundle, properties) {
-        // For the main reference, we always want to get the reference of the object without the collection part,
-        // so we pass the typeBundle to `getReferenceName` but with the isCollection flag set to false.
-        const mainReferenceName = this.getReferenceName(Object.assign(Object.assign({}, typeBundle), { isCollection: false }));
-        const mainReference = {
-            referencedClass: mainReferenceName,
-            schema: {
-                type: 'object',
-                properties: properties,
-            },
-        };
-        const referencedComponents = [mainReference];
-        if (!typeBundle.isCollection) {
-            return referencedComponents;
-        }
-        return [
-            {
-                referencedClass: this.getReferenceName(typeBundle),
-                schema: {
-                    type: 'array',
-                    items: {
-                        $ref: `#/components/schemas/${mainReferenceName}`,
-                    },
-                },
-            },
-            ...referencedComponents,
-        ];
-    }
-    getReferenceType(typeInMirror) {
-        // Returns a valid type supported by OpenApi from a received Apex type.
-        const typeName = typeInMirror.type.toLowerCase();
-        switch (typeName) {
-            case 'boolean':
-                return { schema: { type: 'boolean' }, referenceComponents: [] };
-            case 'date':
-                return { schema: { type: 'string', format: 'date' }, referenceComponents: [] };
-            case 'datetime':
-                return { schema: { type: 'string', format: 'date-time' }, referenceComponents: [] };
-            case 'decimal':
-                return { schema: { type: 'number' }, referenceComponents: [] };
-            case 'double':
-                return { schema: { type: 'number' }, referenceComponents: [] };
-            case 'id':
-                return { schema: { type: 'string' }, referenceComponents: [] };
-            case 'integer':
-                return { schema: { type: 'integer' }, referenceComponents: [] };
-            case 'long':
-                return { schema: { type: 'integer', format: 'int64' }, referenceComponents: [] };
-            case 'string':
-                return { schema: { type: 'string' }, referenceComponents: [] };
-            case 'time':
-                return { schema: { type: 'string', format: 'time' }, referenceComponents: [] };
-            case 'list':
-                return this.buildCollectionPair(typeInMirror);
-            case 'set':
-                return this.buildCollectionPair(typeInMirror);
-            case 'map':
-                // For Maps, we treat them as objects but do not try to define their shape, because their keys can vary
-                // at runtime.
-                return { schema: { type: 'object' }, referenceComponents: [] };
-            case 'object':
-                return { schema: { type: 'object' }, referenceComponents: [] };
-            default:
-                // If we got here we are dealing with a non-primitive (most likely a custom class or an SObject).
-                const referencedType = types_repository_1.TypesRepository.getInstance().getFromAllByName(typeName);
-                if (!referencedType) {
-                    return { schema: { type: 'object' }, referenceComponents: [] };
-                }
-                const reference = this.buildReferenceFromType(Object.assign(Object.assign({}, referencedType), { isCollection: false, referenceOverrides: [], originalTypeName: typeName }));
-                return {
-                    schema: reference.entrypointReferenceObject,
-                    referenceComponents: [...reference.referenceComponents],
-                };
-        }
-    }
-    buildCollectionPair(typeInMirror) {
-        const innerReference = this.getReferenceType(typeInMirror.ofType);
-        return {
-            schema: { type: 'array', items: innerReference.schema },
-            referenceComponents: [...innerReference.referenceComponents],
-        };
-    }
-}
-exports.ReferenceBuilder = ReferenceBuilder;
-class ReferenceOverrides {
-    static build(referenceAsString) {
-        const cleanedUpReference = referenceAsString.replace(/[\[\]]/g, '');
-        const referenceStrings = cleanedUpReference.split(',').map((item) => item.replace(/\s/g, ''));
-        return referenceStrings.map((item) => {
-            const [propertyName, referenceName] = item.split(':');
-            return { propertyName, referenceName };
-        });
-    }
-}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReferenceBuilder = void 0;
+const yaml = require("js-yaml");
+const types_repository_1 = require("../../../model/types-repository");
+class ReferenceBuilder {
+    constructor() {
+        this.isReferenceString = (targetObject) => {
+            return typeof targetObject === 'string' || targetObject instanceof String;
+        };
+    }
+    build(referencedTypeName) {
+        const originalTypeName = referencedTypeName;
+        // Checking for inline overrides of the type: [memberName:ClassOverrideName]
+        const regexForSchemaOverrides = /\[(.*?)]/g;
+        const schemaOverrides = referencedTypeName.match(regexForSchemaOverrides);
+        let referenceOverrides = [];
+        if (schemaOverrides && schemaOverrides.length > 0) {
+            referenceOverrides = ReferenceOverrides.build(schemaOverrides[0]);
+            referencedTypeName = referencedTypeName.replace(regexForSchemaOverrides, '');
+        }
+        const [parsedReferencedType, isCollection] = this.handlePossibleCollectionReference(referencedTypeName);
+        const referencedTypeBundle = types_repository_1.TypesRepository.getInstance().getFromAllByName(parsedReferencedType);
+        if (!referencedTypeBundle) {
+            throw new Error(`The referenced type ${referencedTypeName} was not found.`);
+        }
+        if (referencedTypeBundle.type.type_name !== 'class') {
+            throw new Error(`Expected the referenced type to be a class, but found a ${referencedTypeBundle.type.type_name}.`);
+        }
+        const typeBundleWithIsCollection = Object.assign(Object.assign({}, referencedTypeBundle), { originalTypeName: originalTypeName, isCollection: isCollection, referenceOverrides: referenceOverrides });
+        return this.buildReferenceFromType(typeBundleWithIsCollection);
+    }
+    /**
+     * Returns a tuple where the first value is the name of the reference without any collection related values
+     * and the second is a boolean representing if we are dealing with a collection or not.
+     * @param referencedTypeName The received raw type name.
+     * @private
+     */
+    handlePossibleCollectionReference(referencedTypeName) {
+        referencedTypeName = referencedTypeName.toLowerCase();
+        if (referencedTypeName.startsWith('list<') && referencedTypeName.endsWith('>')) {
+            referencedTypeName = referencedTypeName.replace('list<', '');
+            referencedTypeName = referencedTypeName.replace('>', '');
+            return [referencedTypeName, true];
+        }
+        if (referencedTypeName.startsWith('set<') && referencedTypeName.endsWith('>')) {
+            referencedTypeName = referencedTypeName.replace('set<', '');
+            referencedTypeName = referencedTypeName.replace('>', '');
+            return [referencedTypeName, true];
+        }
+        return [referencedTypeName, false];
+    }
+    buildReferenceFromType(typeBundle) {
+        // Filtering based on Salesforce's documentation:
+        // https://developer.salesforce.com/docs/atlas.en-us.apexcode.meta/apexcode/apex_rest_methods.htm#ApexRESTUserDefinedTypes
+        // We assume that the class only contains object types allowed by Apex Rest:
+        // "Note that the public, private, or global class member variables must be types allowed by Apex REST"
+        const propertiesAndFields = [
+            ...typeBundle.type.properties,
+            ...typeBundle.type.fields,
+        ]
+            .filter((current) => !current.memberModifiers.includes('static'))
+            .filter((current) => !current.memberModifiers.includes('transient'));
+        const properties = {};
+        let referencedComponents = [];
+        propertiesAndFields.forEach((current) => {
+            var _a, _b;
+            // Check if there are reference overrides for the current property, this takes priority over anything else.
+            const referenceOverride = typeBundle.referenceOverrides.find((currentOverride) => {
+                return currentOverride.propertyName.toLowerCase() === current.name.toLowerCase();
+            });
+            if (referenceOverride) {
+                const reference = this.build(referenceOverride.referenceName);
+                properties[current.name] = reference.entrypointReferenceObject;
+                reference.referenceComponents.forEach((current) => referencedComponents.push(current));
+            }
+            else {
+                // Check for "@http-schema" annotations within properties themselves. If these are specified they
+                // take precedence over the property type itself.
+                const manuallyDefinedHttpSchema = (_a = current.docComment) === null || _a === void 0 ? void 0 : _a.annotations.find((annotation) => annotation.name.toLowerCase() === 'http-schema');
+                if (manuallyDefinedHttpSchema) {
+                    this.handleOverriddenSchema(manuallyDefinedHttpSchema, properties, current, referencedComponents);
+                }
+                else {
+                    const pair = this.getReferenceType(current.typeReference);
+                    properties[current.name] = pair.schema;
+                    referencedComponents.push(...pair.referenceComponents);
+                }
+            }
+            properties[current.name].description = (_b = current.docComment) === null || _b === void 0 ? void 0 : _b.description;
+        });
+        const mainReferenceComponents = this.buildMainReferenceComponent(typeBundle, properties);
+        // Make sure to add the "main" reference first
+        referencedComponents = [...mainReferenceComponents, ...referencedComponents];
+        return {
+            entrypointReferenceObject: {
+                $ref: `#/components/schemas/${this.getReferenceName(typeBundle)}`,
+            },
+            referenceComponents: referencedComponents,
+        };
+    }
+    handleOverriddenSchema(manuallyDefinedHttpSchema, properties, current, referencedComponents) {
+        // This can be of type ApexDocSchemaObject
+        const inYaml = manuallyDefinedHttpSchema === null || manuallyDefinedHttpSchema === void 0 ? void 0 : manuallyDefinedHttpSchema.bodyLines.reduce((prev, current, _) => prev + '\n' + current);
+        const asJson = yaml.load(inYaml);
+        const isReferenceString = this.isReferenceString(asJson);
+        if (isReferenceString) {
+            const reference = this.build(asJson);
+            properties[current.name] = reference.entrypointReferenceObject;
+            reference.referenceComponents.forEach((current) => referencedComponents.push(current));
+        }
+        else {
+            // If we are dealing with a manually defined schema object, we can add it directly to the "properties" map,
+            // because we don't need to add a reference component.
+            properties[current.name] = asJson;
+        }
+    }
+    getReferenceName(typeBundle) {
+        var _a;
+        let referenceName = typeBundle.type.name;
+        if (typeBundle.isChild) {
+            referenceName = `${(_a = typeBundle.parentType) === null || _a === void 0 ? void 0 : _a.name}.${typeBundle.type.name}`;
+        }
+        if (typeBundle.isCollection) {
+            referenceName = `${referenceName}_array`;
+        }
+        if (typeBundle.referenceOverrides.length) {
+            referenceName = `${referenceName}_${typeBundle.originalTypeName}`;
+        }
+        return referenceName;
+    }
+    buildMainReferenceComponent(typeBundle, properties) {
+        // For the main reference, we always want to get the reference of the object without the collection part,
+        // so we pass the typeBundle to `getReferenceName` but with the isCollection flag set to false.
+        const mainReferenceName = this.getReferenceName(Object.assign(Object.assign({}, typeBundle), { isCollection: false }));
+        const mainReference = {
+            referencedClass: mainReferenceName,
+            schema: {
+                type: 'object',
+                properties: properties,
+            },
+        };
+        const referencedComponents = [mainReference];
+        if (!typeBundle.isCollection) {
+            return referencedComponents;
+        }
+        return [
+            {
+                referencedClass: this.getReferenceName(typeBundle),
+                schema: {
+                    type: 'array',
+                    items: {
+                        $ref: `#/components/schemas/${mainReferenceName}`,
+                    },
+                },
+            },
+            ...referencedComponents,
+        ];
+    }
+    getReferenceType(typeInMirror) {
+        // Returns a valid type supported by OpenApi from a received Apex type.
+        const typeName = typeInMirror.type.toLowerCase();
+        switch (typeName) {
+            case 'boolean':
+                return { schema: { type: 'boolean' }, referenceComponents: [] };
+            case 'date':
+                return { schema: { type: 'string', format: 'date' }, referenceComponents: [] };
+            case 'datetime':
+                return { schema: { type: 'string', format: 'date-time' }, referenceComponents: [] };
+            case 'decimal':
+                return { schema: { type: 'number' }, referenceComponents: [] };
+            case 'double':
+                return { schema: { type: 'number' }, referenceComponents: [] };
+            case 'id':
+                return { schema: { type: 'string' }, referenceComponents: [] };
+            case 'integer':
+                return { schema: { type: 'integer' }, referenceComponents: [] };
+            case 'long':
+                return { schema: { type: 'integer', format: 'int64' }, referenceComponents: [] };
+            case 'string':
+                return { schema: { type: 'string' }, referenceComponents: [] };
+            case 'time':
+                return { schema: { type: 'string', format: 'time' }, referenceComponents: [] };
+            case 'list':
+                return this.buildCollectionPair(typeInMirror);
+            case 'set':
+                return this.buildCollectionPair(typeInMirror);
+            case 'map':
+                // For Maps, we treat them as objects but do not try to define their shape, because their keys can vary
+                // at runtime.
+                return { schema: { type: 'object' }, referenceComponents: [] };
+            case 'object':
+                return { schema: { type: 'object' }, referenceComponents: [] };
+            default:
+                // If we got here we are dealing with a non-primitive (most likely a custom class or an SObject).
+                const referencedType = types_repository_1.TypesRepository.getInstance().getFromAllByName(typeName);
+                if (!referencedType) {
+                    return { schema: { type: 'object' }, referenceComponents: [] };
+                }
+                const reference = this.buildReferenceFromType(Object.assign(Object.assign({}, referencedType), { isCollection: false, referenceOverrides: [], originalTypeName: typeName }));
+                return {
+                    schema: reference.entrypointReferenceObject,
+                    referenceComponents: [...reference.referenceComponents],
+                };
+        }
+    }
+    buildCollectionPair(typeInMirror) {
+        const innerReference = this.getReferenceType(typeInMirror.ofType);
+        return {
+            schema: { type: 'array', items: innerReference.schema },
+            referenceComponents: [...innerReference.referenceComponents],
+        };
+    }
+}
+exports.ReferenceBuilder = ReferenceBuilder;
+class ReferenceOverrides {
+    static build(referenceAsString) {
+        const cleanedUpReference = referenceAsString.replace(/[\[\]]/g, '');
+        const referenceStrings = cleanedUpReference.split(',').map((item) => item.replace(/\s/g, ''));
+        return referenceStrings.map((item) => {
+            const [propertyName, referenceName] = item.split(':');
+            return { propertyName, referenceName };
+        });
+    }
+}
 //# sourceMappingURL=ReferenceBuilder.js.map

package/lib/transpiler/openapi/parsers/RequestBodyBuilder.d.ts

@@ -1,10 +1,10 @@
-import { RequestBody } from '../../../model/openapi/open-api-types';
-import { Reference } from './ReferenceBuilder';
-import { ApexDocHttpRequestBody } from '../../../model/openapi/apex-doc-types';
-import { Builder } from './Builder';
-/**
- * Parses and builds OpenApi Request Body objects.
- */
-export declare class RequestBodyBuilder extends Builder<RequestBody, ApexDocHttpRequestBody> {
-    buildBody(apexRequestBody: ApexDocHttpRequestBody, reference?: Reference): RequestBody;
-}
+import { RequestBody } from '../../../model/openapi/open-api-types';
+import { Reference } from './ReferenceBuilder';
+import { ApexDocHttpRequestBody } from '../../../model/openapi/apex-doc-types';
+import { Builder } from './Builder';
+/**
+ * Parses and builds OpenApi Request Body objects.
+ */
+export declare class RequestBodyBuilder extends Builder<RequestBody, ApexDocHttpRequestBody> {
+    buildBody(apexRequestBody: ApexDocHttpRequestBody, reference?: Reference): RequestBody;
+}

package/lib/transpiler/openapi/parsers/RequestBodyBuilder.js

@@ -1,20 +1,20 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RequestBodyBuilder = void 0;
-const Builder_1 = require("./Builder");
-/**
- * Parses and builds OpenApi Request Body objects.
- */
-class RequestBodyBuilder extends Builder_1.Builder {
-    buildBody(apexRequestBody, reference) {
-        return {
-            description: apexRequestBody.description,
-            content: {
-                'application/json': { schema: this.getOpenApiSchemaFromApexDocSchema(apexRequestBody, reference) },
-            },
-            required: apexRequestBody.required,
-        };
-    }
-}
-exports.RequestBodyBuilder = RequestBodyBuilder;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestBodyBuilder = void 0;
+const Builder_1 = require("./Builder");
+/**
+ * Parses and builds OpenApi Request Body objects.
+ */
+class RequestBodyBuilder extends Builder_1.Builder {
+    buildBody(apexRequestBody, reference) {
+        return {
+            description: apexRequestBody.description,
+            content: {
+                'application/json': { schema: this.getOpenApiSchemaFromApexDocSchema(apexRequestBody, reference) },
+            },
+            required: apexRequestBody.required,
+        };
+    }
+}
+exports.RequestBodyBuilder = RequestBodyBuilder;
 //# sourceMappingURL=RequestBodyBuilder.js.map

package/lib/transpiler/openapi/parsers/ResponsesBuilder.d.ts

@@ -1,7 +1,7 @@
-import { ResponseObject } from '../../../model/openapi/open-api-types';
-import { Reference } from './ReferenceBuilder';
-import { ApexDocHttpResponse } from '../../../model/openapi/apex-doc-types';
-import { Builder } from './Builder';
-export declare class ResponsesBuilder extends Builder<ResponseObject, ApexDocHttpResponse> {
-    buildBody(apexDocResponseDefinition: ApexDocHttpResponse, reference?: Reference): ResponseObject;
-}
+import { ResponseObject } from '../../../model/openapi/open-api-types';
+import { Reference } from './ReferenceBuilder';
+import { ApexDocHttpResponse } from '../../../model/openapi/apex-doc-types';
+import { Builder } from './Builder';
+export declare class ResponsesBuilder extends Builder<ResponseObject, ApexDocHttpResponse> {
+    buildBody(apexDocResponseDefinition: ApexDocHttpResponse, reference?: Reference): ResponseObject;
+}

package/lib/transpiler/openapi/parsers/ResponsesBuilder.js

@@ -1,22 +1,22 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ResponsesBuilder = void 0;
-const Builder_1 = require("./Builder");
-class ResponsesBuilder extends Builder_1.Builder {
-    buildBody(apexDocResponseDefinition, reference) {
-        let description = `Status code ${apexDocResponseDefinition.statusCode}`;
-        if (apexDocResponseDefinition.description) {
-            description = apexDocResponseDefinition.description;
-        }
-        return {
-            description: description,
-            content: {
-                'application/json': {
-                    schema: this.getOpenApiSchemaFromApexDocSchema(apexDocResponseDefinition, reference),
-                },
-            },
-        };
-    }
-}
-exports.ResponsesBuilder = ResponsesBuilder;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponsesBuilder = void 0;
+const Builder_1 = require("./Builder");
+class ResponsesBuilder extends Builder_1.Builder {
+    buildBody(apexDocResponseDefinition, reference) {
+        let description = `Status code ${apexDocResponseDefinition.statusCode}`;
+        if (apexDocResponseDefinition.description) {
+            description = apexDocResponseDefinition.description;
+        }
+        return {
+            description: description,
+            content: {
+                'application/json': {
+                    schema: this.getOpenApiSchemaFromApexDocSchema(apexDocResponseDefinition, reference),
+                },
+            },
+        };
+    }
+}
+exports.ResponsesBuilder = ResponsesBuilder;
 //# sourceMappingURL=ResponsesBuilder.js.map

package/lib/transpiler/processor-type-transpiler.d.ts

@@ -1,10 +1,10 @@
-import { Type } from '@cparra/apex-reflection';
-import { FileContainer } from './file-container';
-export type LinkingStrategy = 'root-relative' | 'path-relative';
-export default abstract class ProcessorTypeTranspiler {
-    onBeforeProcess: ((types: Type[]) => void) | undefined;
-    abstract onProcess(type: Type): void;
-    onAfterProcess: ((types: Type[]) => void) | undefined;
-    abstract fileBuilder(): FileContainer;
-    getLinkingStrategy(): LinkingStrategy;
-}
+import { Type } from '@cparra/apex-reflection';
+import { FileContainer } from './file-container';
+export type LinkingStrategy = 'root-relative' | 'path-relative';
+export default abstract class ProcessorTypeTranspiler {
+    onBeforeProcess: ((types: Type[]) => void) | undefined;
+    abstract onProcess(type: Type): void;
+    onAfterProcess: ((types: Type[]) => void) | undefined;
+    abstract fileBuilder(): FileContainer;
+    getLinkingStrategy(): LinkingStrategy;
+}

package/lib/transpiler/processor-type-transpiler.js

@@ -1,9 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-class ProcessorTypeTranspiler {
-    getLinkingStrategy() {
-        return 'root-relative';
-    }
-}
-exports.default = ProcessorTypeTranspiler;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class ProcessorTypeTranspiler {
+    getLinkingStrategy() {
+        return 'root-relative';
+    }
+}
+exports.default = ProcessorTypeTranspiler;
 //# sourceMappingURL=processor-type-transpiler.js.map

package/lib/transpiler/transpiler.d.ts

@@ -1,5 +1,5 @@
-import { Type } from '@cparra/apex-reflection';
-import ProcessorTypeTranspiler from './processor-type-transpiler';
-export default class Transpiler {
-    static generate(types: Type[], processor: ProcessorTypeTranspiler): void;
-}
+import { Type } from '@cparra/apex-reflection';
+import ProcessorTypeTranspiler from './processor-type-transpiler';
+export default class Transpiler {
+    static generate(types: Type[], processor: ProcessorTypeTranspiler): void;
+}