@aws/nx-plugin 1.0.0-rc.3 → 1.0.0-rc.30

package/src/open-api/utils/codegen-data.js

@@ -1,40 +1,37 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildOpenApiCodeGenData = void 0;
-const tslib_1 = require("tslib");
 /**
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
- */
-const gen = tslib_1.__importStar(require("@hey-api/openapi-ts"));
-const normalise_1 = require("./normalise");
-const lodash_camelcase_1 = tslib_1.__importDefault(require("lodash.camelcase"));
-const lodash_orderby_1 = tslib_1.__importDefault(require("lodash.orderby"));
-const lodash_uniqby_1 = tslib_1.__importDefault(require("lodash.uniqby"));
-const lodash_trim_1 = tslib_1.__importDefault(require("lodash.trim"));
-const refs_1 = require("./refs");
-const names_1 = require("../../utils/names");
-const languages_1 = require("./codegen-data/languages");
-const types_1 = require("./codegen-data/types");
+ */ import * as gen from "@hey-api/openapi-ts";
+import camelCase from "lodash.camelcase";
+import orderBy from "lodash.orderby";
+import trim from "lodash.trim";
+import uniqBy from "lodash.uniqby";
+import { kebabCase, pascalCase, snakeCase, toClassName, upperFirst } from "../../utils/names.js";
+import { toPythonName, toPythonType, toTypeScriptModelName, toTypeScriptName, toTypeScriptType } from "./codegen-data/languages.js";
+import { COLLECTION_TYPES, COMPOSED_SCHEMA_TYPES, flattenModelLink, PRIMITIVE_TYPES, STREAMING_CONTENT_TYPES, VENDOR_EXTENSIONS } from "./codegen-data/types.js";
+import { normaliseOpenApiSpecForCodeGen } from "./normalise.js";
+import { isRef, resolveIfRef, splitRef } from "./refs.js";
 /**
  * Builds a data structure from an OpenAPI spec which can be used to generate code
- */
-const buildOpenApiCodeGenData = async (inSpec) => {
+ */ export const buildOpenApiCodeGenData = async (inSpec)=>{
     // Ensure spec is ready for codegen
-    const spec = (0, normalise_1.normaliseOpenApiSpecForCodeGen)(inSpec);
+    const spec = normaliseOpenApiSpecForCodeGen(inSpec);
     // Build the initial data, which we will augment with additional information
     const data = await buildInitialCodeGenData(spec);
     // Ensure the models have their links set when they are arrays/dictionaries
     ensureModelLinks(spec, data);
     // Mutate the models with enough data to render composite models in the templates
     ensureCompositeModels(data);
-    const modelsByName = Object.fromEntries(data.models.map((m) => [m.name, m]));
+    const modelsByName = Object.fromEntries(data.models.map((m)=>[
+            m.name,
+            m
+        ]));
     // Augment operations with additional data
-    for (const service of data.services) {
+    for (const service of data.services){
         // Keep track of the request and response models we need the service (ie api client) to import
         const requestModelImports = [];
         const responseModelImports = [];
-        for (const op of service.operations) {
+        for (const op of service.operations){
             // Extract the operation back from the openapi spec
             const specOp = spec?.paths?.[op.path]?.[op.method.toLowerCase()];
             op.name = op.id ?? op.name;
@@ -50,17 +47,17 @@ const buildOpenApiCodeGenData = async (inSpec) => {
             copyVendorExtensions(specOp ?? {}, op.vendorExtensions);
             if (specOp) {
                 // Add all response models to the response model imports
-                responseModelImports.push(...op.responses
-                    .filter((r) => r.export === 'reference')
-                    .map((r) => r.type));
-                for (const response of op.responses) {
+                responseModelImports.push(...op.responses.filter((r)=>r.export === 'reference').map((r)=>r.type));
+                for (const response of op.responses){
                     // Validate that the response is not a composite schema of primitives since we cannot determine what
                     // the type of the response is (it all comes back as text!)
-                    if (response.export === 'reference' &&
-                        types_1.COMPOSED_SCHEMA_TYPES.has(modelsByName[response.type]?.export)) {
-                        const composedPrimitives = modelsByName[response.type].composedPrimitives.filter((p) => !['array', 'dictionary'].includes(p.export));
+                    if (response.export === 'reference' && COMPOSED_SCHEMA_TYPES.has(modelsByName[response.type]?.export)) {
+                        const composedPrimitives = modelsByName[response.type].composedPrimitives.filter((p)=>![
+                                'array',
+                                'dictionary'
+                            ].includes(p.export));
                         if (composedPrimitives.length > 0) {
-                            throw new Error(`Operation "${op.method} ${op.path}" returns a composite schema of primitives with ${(0, lodash_camelcase_1.default)(modelsByName[response.type].export)}, which cannot be distinguished at runtime`);
+                            throw new Error(`Operation "${op.method} ${op.path}" returns a composite schema of primitives with ${camelCase(modelsByName[response.type].export)}, which cannot be distinguished at runtime`);
                         }
                     }
                     const matchingSpecResponse = specOp.responses[`${response.code}`];
@@ -69,45 +66,44 @@ const buildOpenApiCodeGenData = async (inSpec) => {
                     // has content
                     if (matchingSpecResponse) {
                         // Resolve the ref if necessary
-                        const specResponse = (0, refs_1.resolveIfRef)(spec, matchingSpecResponse);
+                        const specResponse = resolveIfRef(spec, matchingSpecResponse);
                         // When there's no content, we set the type to 'void'
                         if (!specResponse.content) {
                             response.type = 'void';
-                        }
-                        else {
+                        } else {
                             // Add the response media types
                             const mediaTypes = Object.keys(specResponse.content);
                             response.mediaTypes = mediaTypes;
-                            for (const mediaType of mediaTypes) {
-                                const responseContent = specResponse.content?.[mediaType] ??
-                                    Object.values(specResponse.content)[0];
-                                const responseSchema = (0, refs_1.resolveIfRef)(spec, responseContent.schema);
+                            for (const mediaType of mediaTypes){
+                                const responseContent = specResponse.content?.[mediaType] ?? Object.values(specResponse.content)[0];
+                                const responseSchema = resolveIfRef(spec, responseContent.schema);
                                 if (responseSchema) {
                                     await mutateWithOpenapiSchemaProperties(spec, response, responseSchema, modelsByName);
                                 }
-                                if (types_1.STREAMING_CONTENT_TYPES.has(mediaType) &&
-                                    'itemSchema' in responseContent) {
+                                if (STREAMING_CONTENT_TYPES.has(mediaType) && 'itemSchema' in responseContent) {
                                     response.isJsonlStreaming = true;
-                                    response.itemSchemaModel =
-                                        await buildOrReferenceModel(spec, modelsByName, responseContent.itemSchema);
+                                    response.itemSchemaModel = await buildOrReferenceModel(spec, modelsByName, responseContent.itemSchema);
                                 }
                             }
                         }
                     }
                 }
             }
-            const specParametersByName = Object.fromEntries((specOp?.parameters ?? []).map((p) => {
-                const param = (0, refs_1.resolveIfRef)(spec, p);
-                return [param.name, param];
+            const specParametersByName = Object.fromEntries((specOp?.parameters ?? []).map((p)=>{
+                const param = resolveIfRef(spec, p);
+                return [
+                    param.name,
+                    param
+                ];
             }));
             // Loop through the parameters
-            for (const parameter of op.parameters) {
+            for (const parameter of op.parameters){
                 // Add the request model import
                 if (parameter.export === 'reference') {
                     requestModelImports.push(parameter.type);
                 }
                 const specParameter = specParametersByName[parameter.prop];
-                const specParameterSchema = (0, refs_1.resolveIfRef)(spec, specParameter?.schema);
+                const specParameterSchema = resolveIfRef(spec, specParameter?.schema);
                 if (specParameterSchema) {
                     await mutateWithOpenapiSchemaProperties(spec, parameter, specParameterSchema, modelsByName);
                 }
@@ -122,10 +118,10 @@ const buildOpenApiCodeGenData = async (inSpec) => {
                     parameter.in = 'body';
                     // The request body is not in the "parameters" section of the openapi spec so we won't have added the schema
                     // properties above. Find it here.
-                    const specBody = (0, refs_1.resolveIfRef)(spec, specOp?.requestBody);
+                    const specBody = resolveIfRef(spec, specOp?.requestBody);
                     if (specBody) {
                         if (parameter.mediaType) {
-                            const bodySchema = (0, refs_1.resolveIfRef)(spec, specBody.content?.[parameter.mediaType]?.schema);
+                            const bodySchema = resolveIfRef(spec, specBody.content?.[parameter.mediaType]?.schema);
                             if (bodySchema) {
                                 await mutateWithOpenapiSchemaProperties(spec, parameter, bodySchema, modelsByName);
                             }
@@ -133,25 +129,22 @@ const buildOpenApiCodeGenData = async (inSpec) => {
                         // Track all the media types that can be accepted in the request body
                         parameter.mediaTypes = Object.keys(specBody.content);
                     }
-                }
-                else if (['query', 'header'].includes(parameter.in) &&
-                    specParameter) {
+                } else if ([
+                    'query',
+                    'header'
+                ].includes(parameter.in) && specParameter) {
                     // Translate style/explode to OpenAPI v2 style collectionFormat
                     // https://spec.openapis.org/oas/v3.0.3.html#style-values
-                    const style = specParameter.style ??
-                        (parameter.in === 'query' ? 'form' : 'simple');
+                    const style = specParameter.style ?? (parameter.in === 'query' ? 'form' : 'simple');
                     const explode = specParameter.explode ?? style === 'form';
                     if (parameter.in === 'query') {
-                        parameter.collectionFormat = explode
-                            ? 'multi'
-                            : ({
-                                spaceDelimited: 'ssv',
-                                pipeDelimited: 'tsv',
-                                simple: 'csv',
-                                form: 'csv',
-                            }[style] ?? 'multi');
-                    }
-                    else {
+                        parameter.collectionFormat = explode ? 'multi' : ({
+                            spaceDelimited: 'ssv',
+                            pipeDelimited: 'tsv',
+                            simple: 'csv',
+                            form: 'csv'
+                        })[style] ?? 'multi';
+                    } else {
                         // parameter.in === "header"
                         parameter.collectionFormat = explode ? 'multi' : 'csv';
                     }
@@ -161,26 +154,22 @@ const buildOpenApiCodeGenData = async (inSpec) => {
             // Add language types to response models
             (op.responses ?? []).forEach(mutateModelWithAdditionalTypes);
             // Sort responses by code
-            op.responses = (0, lodash_orderby_1.default)(op.responses, (r) => r.code);
+            op.responses = orderBy(op.responses, (r)=>r.code);
             // Result is the lowest successful response, otherwise is the 2XX or default response
-            const result = op.responses.find((r) => typeof r.code === 'number' && r.code >= 200 && r.code < 300);
-            op.result =
-                result ??
-                    op.responses.find((r) => r.code === '2XX' || r.code === 'default');
+            const result = op.responses.find((r)=>typeof r.code === 'number' && r.code >= 200 && r.code < 300);
+            op.result = result ?? op.responses.find((r)=>r.code === '2XX' || r.code === 'default');
             // Add variants of operation name
-            op.operationIdPascalCase = (0, names_1.pascalCase)(op.uniqueName);
-            op.operationIdKebabCase = (0, names_1.kebabCase)(op.uniqueName);
-            op.operationIdSnakeCase = (0, languages_1.toPythonName)('operation', op.uniqueName);
+            op.operationIdPascalCase = pascalCase(op.uniqueName);
+            op.operationIdKebabCase = kebabCase(op.uniqueName);
+            op.operationIdSnakeCase = toPythonName('operation', op.uniqueName);
             // Add request type name (after operationIdPascalCase is set)
             if (op.parameters && op.parameters.length > 0) {
                 const baseRequestTypeName = `${op.operationIdPascalCase}Request`;
                 const hasConflict = !!spec.components?.schemas?.[baseRequestTypeName];
                 if (hasConflict) {
                     // Use OperationRequest suffix when there's a conflict
-                    op.requestTypeName =
-                        `${op.operationIdPascalCase}OperationRequest`;
-                }
-                else {
+                    op.requestTypeName = `${op.operationIdPascalCase}OperationRequest`;
+                } else {
                     // Use standard Request suffix when no conflict
                     op.requestTypeName = baseRequestTypeName;
                 }
@@ -188,27 +177,29 @@ const buildOpenApiCodeGenData = async (inSpec) => {
             mutateOperationWithAdditionalData(op);
         }
         // Lexicographical ordering of operations
-        service.operations = (0, lodash_orderby_1.default)(service.operations, (op) => op.uniqueName);
+        service.operations = orderBy(service.operations, (op)=>op.uniqueName);
         // Add the models to import
-        service.modelImports = (0, lodash_orderby_1.default)((0, lodash_uniqby_1.default)([...service.imports, ...requestModelImports, ...responseModelImports], (x) => x));
+        service.modelImports = orderBy(uniqBy([
+            ...service.imports,
+            ...requestModelImports,
+            ...responseModelImports
+        ], (x)=>x));
         // Add the service class name
         service.className = `${service.name}Api`;
-        service.classNameSnakeCase = (0, names_1.snakeCase)(service.className);
-        service.nameSnakeCase = (0, names_1.snakeCase)(service.name);
+        service.classNameSnakeCase = snakeCase(service.className);
+        service.nameSnakeCase = snakeCase(service.name);
     }
     // All operations across all services
-    const allOperations = (0, lodash_uniqby_1.default)(data.services.flatMap((s) => s.operations), (o) => o.uniqueName);
+    const allOperations = uniqBy(data.services.flatMap((s)=>s.operations), (o)=>o.uniqueName);
     // Add additional models for operation parameters
     data.models = [
         ...data.models,
-        ...allOperations.flatMap((op) => {
+        ...allOperations.flatMap((op)=>{
             if (op.parameters && op.parameters.length > 0) {
                 // Build a collection of request parameter models to create based on their position (ie 'in' in the openapi spec, eg body, query, path, header, etc)
                 const parametersByPosition = {};
-                op.parameters
-                    .filter(
-                // We filter out (return false for) request bodies which we "inline" - ie we don't create a property which points to the body, the request will only be the body itself
-                (p) => {
+                op.parameters.filter(// We filter out (return false for) request bodies which we "inline" - ie we don't create a property which points to the body, the request will only be the body itself
+                (p)=>{
                     // Always create models for non-body parameters
                     if (p.in !== 'body') {
                         return true;
@@ -219,19 +210,16 @@ const buildOpenApiCodeGenData = async (inSpec) => {
                     }
                     // We inline object bodies, so long as they aren't dictionaries (as dictionary keys could clash with other parameters),
                     // and so long as they don't have a property name that clashes with another parameter
-                    const hasClashingPropertyName = (modelsByName?.[p.type]?.properties ?? []).some((prop) => op.parameters.some((param) => param.name === prop.name));
-                    if (p.export === 'reference' &&
-                        modelsByName?.[p.type]?.export !== 'dictionary' &&
-                        !hasClashingPropertyName) {
+                    const hasClashingPropertyName = (modelsByName?.[p.type]?.properties ?? []).some((prop)=>op.parameters.some((param)=>param.name === prop.name));
+                    if (p.export === 'reference' && modelsByName?.[p.type]?.export !== 'dictionary' && !hasClashingPropertyName) {
                         return false;
                     }
                     // Don't inline anything else
                     return true;
-                })
-                    .forEach((parameter) => {
+                }).forEach((parameter)=>{
                     parametersByPosition[parameter.in] = [
-                        ...(parametersByPosition[parameter.in] ?? []),
-                        parameter,
+                        ...parametersByPosition[parameter.in] ?? [],
+                        parameter
                     ];
                 });
                 // Ensure that if we have an explicit body parameter, it's called "body"
@@ -241,8 +229,8 @@ const buildOpenApiCodeGenData = async (inSpec) => {
                     requestBodyParameter.prop = 'body';
                 }
                 op.explicitRequestBodyParameter = requestBodyParameter;
-                return Object.entries(parametersByPosition).map(([position, parameters]) => {
-                    const name = `${op.operationIdPascalCase}Request${(0, names_1.upperFirst)(position)}Parameters`;
+                return Object.entries(parametersByPosition).map(([position, parameters])=>{
+                    const name = `${op.operationIdPascalCase}Request${upperFirst(position)}Parameters`;
                     return {
                         $refs: [],
                         base: name,
@@ -260,66 +248,66 @@ const buildOpenApiCodeGenData = async (inSpec) => {
                         isDefinition: false,
                         isNullable: false,
                         isReadOnly: false,
-                        isRequired: true,
+                        isRequired: true
                     };
                 });
             }
             return [];
-        }),
+        })
     ];
     // Augment models with additional data
-    for (const model of data.models) {
+    for (const model of data.models){
         // Add a snake_case name
-        model.nameSnakeCase = (0, languages_1.toPythonName)('model', model.name);
+        model.nameSnakeCase = toPythonName('model', model.name);
         const matchingSpecModel = spec?.components?.schemas?.[model.name];
         if (matchingSpecModel) {
-            const specModel = (0, refs_1.resolveIfRef)(spec, matchingSpecModel);
+            const specModel = resolveIfRef(spec, matchingSpecModel);
             await mutateWithOpenapiSchemaProperties(spec, model, specModel, modelsByName);
             // Add unique imports
-            model.uniqueImports = (0, lodash_orderby_1.default)((0, lodash_uniqby_1.default)([
+            model.uniqueImports = orderBy(uniqBy([
                 ...model.imports,
                 // Include property imports, if any
-                ...model.properties
-                    .filter((p) => p.export === 'reference')
-                    .map((p) => p.type),
-            ], (x) => x)).filter((modelImport) => modelImport !== model.name); // Filter out self for recursive model references
+                ...model.properties.filter((p)=>p.export === 'reference').map((p)=>p.type)
+            ], (x)=>x)).filter((modelImport)=>modelImport !== model.name); // Filter out self for recursive model references
             // Add deprecated flag if present
             model.deprecated = specModel.deprecated || false;
             // Augment properties with additional data
-            for (const property of model.properties) {
+            for (const property of model.properties){
                 const matchingSpecProperty = specModel.properties?.[property.name];
                 if (matchingSpecProperty) {
-                    const specProperty = (0, refs_1.resolveIfRef)(spec, matchingSpecProperty);
+                    const specProperty = resolveIfRef(spec, matchingSpecProperty);
                     await mutateWithOpenapiSchemaProperties(spec, property, specProperty, modelsByName);
                 }
             }
         }
         // Augment properties with additional data
-        model.properties.forEach((property) => {
+        model.properties.forEach((property)=>{
             // Add language-specific names/types
             mutateModelWithAdditionalTypes(property);
         });
     }
-    for (const model of data.models) {
+    for (const model of data.models){
         // Set the model's typescript name and type
-        model.typescriptName = (0, languages_1.toTypeScriptModelName)(model.name);
+        model.typescriptName = toTypeScriptModelName(model.name);
         model.typescriptType = model.typescriptName;
     }
     // Order models lexicographically by name
-    data.models = (0, lodash_orderby_1.default)(data.models, (d) => d.name);
+    data.models = orderBy(data.models, (d)=>d.name);
     // Order services so default appears first, then otherwise by name
-    data.services = (0, lodash_orderby_1.default)(data.services, (s) => s.name === 'Default' ? '' : s.name);
+    data.services = orderBy(data.services, (s)=>s.name === 'Default' ? '' : s.name);
     // All operations by tags
     const operationsByTag = {};
     const untaggedOperations = [];
-    allOperations.forEach((op) => {
+    allOperations.forEach((op)=>{
         const tags = op.tags;
         if (tags && tags.length > 0) {
-            tags.map(lodash_camelcase_1.default).forEach((tag) => {
-                operationsByTag[tag] = [...(operationsByTag[tag] ?? []), op];
+            tags.map(camelCase).forEach((tag)=>{
+                operationsByTag[tag] = [
+                    ...operationsByTag[tag] ?? [],
+                    op
+                ];
             });
-        }
-        else {
+        } else {
             untaggedOperations.push(op);
         }
     });
@@ -333,31 +321,34 @@ const buildOpenApiCodeGenData = async (inSpec) => {
         info: spec.info,
         allOperations,
         vendorExtensions,
-        className: (0, names_1.toClassName)(spec.info.title),
+        className: toClassName(spec.info.title)
     };
 };
-exports.buildOpenApiCodeGenData = buildOpenApiCodeGenData;
-const buildInitialCodeGenData = async (spec) => {
+const buildInitialCodeGenData = async (spec)=>{
     let data;
     // We create a plugin which will capture the client data
-    const plugin = () => ({
-        name: 'plugin',
-        // eslint-disable-next-line @typescript-eslint/no-empty-function
-        _handler: () => { },
-        _handlerLegacy: ({ client }) => {
-            data = client;
-        },
-    });
+    const plugin = ()=>({
+            name: 'plugin',
+            // eslint-disable-next-line @typescript-eslint/no-empty-function
+            _handler: ()=>{},
+            _handlerLegacy: ({ client })=>{
+                data = client;
+            }
+        });
     // Use @hey-api/openapi-ts to build the initial data structure that we'll generate clients from
     await gen.createClient({
         experimentalParser: false,
         input: {
-            path: spec,
+            path: spec
         },
         output: 'unused',
-        plugins: [plugin()],
+        plugins: [
+            plugin()
+        ],
         dryRun: true,
-        logs: { level: 'silent' },
+        logs: {
+            level: 'silent'
+        }
     });
     if (!data) {
         // If this happens it indicates an update to @hey-api/openapi-ts which has removed the legacy parser
@@ -369,32 +360,37 @@ const buildInitialCodeGenData = async (spec) => {
  * Build a model for a particular primitive schema.
  * Only primitives are supported since we only return one model.
  * For non-primitives, it assumes all referenced subschemas are already models
- */
-const buildModelForPrimitive = async (originalSpec, schema) => {
+ */ const buildModelForPrimitive = async (originalSpec, schema)=>{
     const targetSchemaName = '___aws_nx_plugin_openapi_tmp_schema___';
     const spec = {
         openapi: '3.1.0',
-        info: { title: 'tmp', version: '1.0.0' },
+        info: {
+            title: 'tmp',
+            version: '1.0.0'
+        },
         paths: {},
         components: {
             schemas: {
                 ...originalSpec.components?.schemas,
-                [targetSchemaName]: schema,
-            },
-        },
+                [targetSchemaName]: schema
+            }
+        }
     };
     const data = await buildInitialCodeGenData(spec);
-    const model = data.models.find((m) => m.name === targetSchemaName);
+    const model = data.models.find((m)=>m.name === targetSchemaName);
     if (!model) {
         throw new Error(`Failed to construct model for schema ${JSON.stringify(schema)}`);
     }
     ensureModelLinks(spec, data);
-    await mutateWithOpenapiSchemaProperties(spec, model, schema, Object.fromEntries(data.models.map((m) => [m.name, m])));
+    await mutateWithOpenapiSchemaProperties(spec, model, schema, Object.fromEntries(data.models.map((m)=>[
+            m.name,
+            m
+        ])));
     return model;
 };
-const buildOrReferenceModel = async (spec, modelsByName, schema) => {
-    if ((0, refs_1.isRef)(schema)) {
-        const name = (0, refs_1.splitRef)(schema.$ref)[2];
+const buildOrReferenceModel = async (spec, modelsByName, schema)=>{
+    if (isRef(schema)) {
+        const name = splitRef(schema.$ref)[2];
         return modelsByName[name];
     }
     // Non referenced schemas won't have a model created as they are primitives and aren't covered by @heyapi
@@ -403,15 +399,14 @@ const buildOrReferenceModel = async (spec, modelsByName, schema) => {
 };
 /**
  * Copy vendor extensions from the first parameter to the second
- */
-const copyVendorExtensions = (object, vendorExtensions) => {
-    Object.entries(object ?? {}).forEach(([key, value]) => {
+ */ const copyVendorExtensions = (object, vendorExtensions)=>{
+    Object.entries(object ?? {}).forEach(([key, value])=>{
         if (key.startsWith('x-')) {
             vendorExtensions[key] = value;
         }
     });
 };
-const mutateWithOpenapiSchemaProperties = async (spec, model, schema, modelsByName, visited = new Set()) => {
+const mutateWithOpenapiSchemaProperties = async (spec, model, schema, modelsByName, visited = new Set())=>{
     model.format = schema.format;
     model.isInteger = schema.type === 'integer';
     model.isShort = schema.format === 'int32';
@@ -433,7 +428,7 @@ const mutateWithOpenapiSchemaProperties = async (spec, model, schema, modelsByNa
         // additional properties. Interfaces can have a mixture of explicit properties and additional properties.
         if (model.export === 'dictionary') {
             // Dictionaries contain a special property which is the model itself. Other properties are explicit properties.
-            const explicitProperties = model.properties.filter((p) => !(p.export === 'dictionary' && p.name === model.name));
+            const explicitProperties = model.properties.filter((p)=>!(p.export === 'dictionary' && p.name === model.name));
             if (explicitProperties.length > 0 || schema.patternProperties) {
                 // Treat this model as an interface instead of a dictionary, since this has
                 // explicit properties
@@ -442,30 +437,29 @@ const mutateWithOpenapiSchemaProperties = async (spec, model, schema, modelsByNa
                 model.additionalPropertiesModel = additionalPropertiesModel;
                 model.properties = explicitProperties;
             }
-        }
-        else {
+        } else {
             model.hasAdditionalProperties = true;
             model.additionalPropertiesModel = additionalPropertiesModel;
             // There's a special property named [key: string] which is the definition of the additional properties
             // We remove this so we don't render it as a regular property.
-            model.properties = (model.properties ?? []).filter((p) => p.name !== '[key: string]');
+            model.properties = (model.properties ?? []).filter((p)=>p.name !== '[key: string]');
         }
     }
     // Ensure models with pattern properties are handled correctly
     if (schema.patternProperties) {
-        const patternProperties = (0, refs_1.resolveIfRef)(spec, schema.patternProperties);
+        const patternProperties = resolveIfRef(spec, schema.patternProperties);
         const patternPropertiesModels = [];
         // When there are pattern properties, we don't want to treat models as dictionaries since there can be more than one type of "value"
         // depending on what pattern the key matches
         if (model.export === 'dictionary') {
             model.export = 'interface';
         }
-        for (const [pattern, patternProperty] of Object.entries(patternProperties)) {
+        for (const [pattern, patternProperty] of Object.entries(patternProperties)){
             const patternPropertyModel = await buildOrReferenceModel(spec, modelsByName, patternProperty);
             if (patternPropertyModel) {
                 patternPropertiesModels.push({
                     pattern,
-                    model: patternPropertyModel,
+                    model: patternPropertyModel
                 });
             }
         }
@@ -474,35 +468,27 @@ const mutateWithOpenapiSchemaProperties = async (spec, model, schema, modelsByNa
     }
     mutateModelWithAdditionalTypes(model);
     visited.add(model);
-    const modelLink = (0, types_1.flattenModelLink)(model.link);
+    const modelLink = flattenModelLink(model.link);
     // Also apply to array items recursively
-    if (model.export === 'array' &&
-        modelLink &&
-        'items' in schema &&
-        schema.items &&
-        !visited.has(modelLink)) {
-        const subSchema = (0, refs_1.resolveIfRef)(spec, schema.items);
+    if (model.export === 'array' && modelLink && 'items' in schema && schema.items && !visited.has(modelLink)) {
+        const subSchema = resolveIfRef(spec, schema.items);
         await mutateWithOpenapiSchemaProperties(spec, modelLink, subSchema, modelsByName, visited);
     }
     // Also apply to object properties recursively
-    if (model.export === 'dictionary' &&
-        model.link &&
-        'additionalProperties' in schema &&
-        schema.additionalProperties &&
-        !visited.has(modelLink)) {
-        const subSchema = (0, refs_1.resolveIfRef)(spec, schema.additionalProperties);
+    if (model.export === 'dictionary' && model.link && 'additionalProperties' in schema && schema.additionalProperties && !visited.has(modelLink)) {
+        const subSchema = resolveIfRef(spec, schema.additionalProperties);
         // Additional properties can be "true" rather than a type
         if (subSchema !== true) {
             await mutateWithOpenapiSchemaProperties(spec, modelLink, subSchema, modelsByName, visited);
         }
     }
-    for (const property of model.properties.filter((p) => !visited.has(p) && schema.properties?.[(0, lodash_trim_1.default)(p.name, `"'`)])) {
-        const subSchema = (0, refs_1.resolveIfRef)(spec, schema.properties[(0, lodash_trim_1.default)(property.name, `"'`)]);
+    for (const property of model.properties.filter((p)=>!visited.has(p) && schema.properties?.[trim(p.name, `"'`)])){
+        const subSchema = resolveIfRef(spec, schema.properties[trim(property.name, `"'`)]);
         await mutateWithOpenapiSchemaProperties(spec, property, subSchema, modelsByName, visited);
     }
-    if (types_1.COMPOSED_SCHEMA_TYPES.has(model.export)) {
-        for (let i = 0; i < model.properties.length; i++) {
-            const subSchema = (0, refs_1.resolveIfRef)(spec, schema[(0, lodash_camelcase_1.default)(model.export)]?.[i]);
+    if (COMPOSED_SCHEMA_TYPES.has(model.export)) {
+        for(let i = 0; i < model.properties.length; i++){
+            const subSchema = resolveIfRef(spec, schema[camelCase(model.export)]?.[i]);
             if (subSchema) {
                 await mutateWithOpenapiSchemaProperties(spec, model.properties[i], subSchema, modelsByName, visited);
             }
@@ -511,50 +497,53 @@ const mutateWithOpenapiSchemaProperties = async (spec, model, schema, modelsByNa
 };
 /**
  * Ensure that the "link" property of all dictionary/array models and properties are set recursively
- */
-const ensureModelLinks = (spec, data) => {
-    const modelsByName = Object.fromEntries(data.models.map((m) => [m.name, m]));
+ */ const ensureModelLinks = (spec, data)=>{
+    const modelsByName = Object.fromEntries(data.models.map((m)=>[
+            m.name,
+            m
+        ]));
     const visited = new Set();
     // Ensure set for all models
-    data.models.forEach((model) => {
-        const schema = (0, refs_1.resolveIfRef)(spec, spec?.components?.schemas?.[model.name]);
+    data.models.forEach((model)=>{
+        const schema = resolveIfRef(spec, spec?.components?.schemas?.[model.name]);
         if (schema) {
             // Object schemas should be typed as the model we will create
-            if (schema.type === 'object' &&
-                (schema.properties || schema.patternProperties)) {
+            if (schema.type === 'object' && (schema.properties || schema.patternProperties)) {
                 model.type = model.name;
             }
             _ensureModelLinks(spec, modelsByName, model, schema, visited);
         }
     });
     // Ensure set for all parameters and responses
-    data.services.forEach((service) => {
-        service.operations.forEach((op) => {
+    data.services.forEach((service)=>{
+        service.operations.forEach((op)=>{
             const specOp = spec?.paths?.[op.path]?.[op.method.toLowerCase()];
-            const specParametersByName = Object.fromEntries((specOp?.parameters ?? []).map((p) => {
-                const param = (0, refs_1.resolveIfRef)(spec, p);
-                return [param.name, param];
+            const specParametersByName = Object.fromEntries((specOp?.parameters ?? []).map((p)=>{
+                const param = resolveIfRef(spec, p);
+                return [
+                    param.name,
+                    param
+                ];
             }));
-            op.parameters.forEach((parameter) => {
+            op.parameters.forEach((parameter)=>{
                 const specParameter = specParametersByName[parameter.prop];
-                const specParameterSchema = (0, refs_1.resolveIfRef)(spec, specParameter?.schema);
+                const specParameterSchema = resolveIfRef(spec, specParameter?.schema);
                 if (specParameterSchema) {
                     _ensureModelLinks(spec, modelsByName, parameter, specParameterSchema, visited);
-                }
-                else if (parameter.in === 'body') {
+                } else if (parameter.in === 'body') {
                     // Body is not in the "parameters" section of the OpenAPI spec so we handle it in an explicit case here
-                    const specBody = (0, refs_1.resolveIfRef)(spec, specOp?.requestBody);
-                    const specBodySchema = (0, refs_1.resolveIfRef)(spec, specBody?.content?.[parameter.mediaType]?.schema);
+                    const specBody = resolveIfRef(spec, specOp?.requestBody);
+                    const specBodySchema = resolveIfRef(spec, specBody?.content?.[parameter.mediaType]?.schema);
                     if (specBodySchema) {
                         _ensureModelLinks(spec, modelsByName, parameter, specBodySchema, visited);
                     }
                 }
             });
-            op.responses.forEach((response) => {
-                const specResponse = (0, refs_1.resolveIfRef)(spec, specOp?.responses?.[response.code]);
+            op.responses.forEach((response)=>{
+                const specResponse = resolveIfRef(spec, specOp?.responses?.[response.code]);
                 const mediaTypes = Object.keys(specResponse?.content ?? {});
-                mediaTypes.forEach((mediaType) => {
-                    const responseSchema = (0, refs_1.resolveIfRef)(spec, specResponse?.content?.[mediaType]?.schema);
+                mediaTypes.forEach((mediaType)=>{
+                    const responseSchema = resolveIfRef(spec, specResponse?.content?.[mediaType]?.schema);
                     if (responseSchema) {
                         _ensureModelLinks(spec, modelsByName, response, responseSchema, visited);
                     }
@@ -563,44 +552,37 @@ const ensureModelLinks = (spec, data) => {
         });
     });
 };
-const _ensureModelLinks = (spec, modelsByName, model, schema, visited) => {
+const _ensureModelLinks = (spec, modelsByName, model, schema, visited)=>{
     if (visited.has(model)) {
         return;
     }
     visited.add(model);
-    if (model.export === 'dictionary' &&
-        'additionalProperties' in schema &&
-        schema.additionalProperties) {
-        if ((0, refs_1.isRef)(schema.additionalProperties)) {
-            const name = (0, refs_1.splitRef)(schema.additionalProperties.$ref)[2];
+    if (model.export === 'dictionary' && 'additionalProperties' in schema && schema.additionalProperties) {
+        if (isRef(schema.additionalProperties)) {
+            const name = splitRef(schema.additionalProperties.$ref)[2];
             if (modelsByName[name] && !model.link) {
                 model.link = modelsByName[name];
             }
+        } else if (model.link && typeof schema.additionalProperties !== 'boolean') {
+            _ensureModelLinks(spec, modelsByName, flattenModelLink(model.link), schema.additionalProperties, visited);
         }
-        else if (model.link && typeof schema.additionalProperties !== 'boolean') {
-            _ensureModelLinks(spec, modelsByName, (0, types_1.flattenModelLink)(model.link), schema.additionalProperties, visited);
-        }
-    }
-    else if (model.export === 'array' && 'items' in schema && schema.items) {
-        if ((0, refs_1.isRef)(schema.items)) {
-            const name = (0, refs_1.splitRef)(schema.items.$ref)[2];
+    } else if (model.export === 'array' && 'items' in schema && schema.items) {
+        if (isRef(schema.items)) {
+            const name = splitRef(schema.items.$ref)[2];
             if (modelsByName[name] && !model.link) {
                 model.link = modelsByName[name];
             }
-        }
-        else if (model.link) {
-            _ensureModelLinks(spec, modelsByName, (0, types_1.flattenModelLink)(model.link), schema.items, visited);
+        } else if (model.link) {
+            _ensureModelLinks(spec, modelsByName, flattenModelLink(model.link), schema.items, visited);
         }
     }
-    model.properties
-        .filter((p) => !visited.has(p) && schema.properties?.[(0, lodash_trim_1.default)(p.name, `"'`)])
-        .forEach((property) => {
-        const subSchema = (0, refs_1.resolveIfRef)(spec, schema.properties[(0, lodash_trim_1.default)(property.name, `"'`)]);
+    model.properties.filter((p)=>!visited.has(p) && schema.properties?.[trim(p.name, `"'`)]).forEach((property)=>{
+        const subSchema = resolveIfRef(spec, schema.properties[trim(property.name, `"'`)]);
         _ensureModelLinks(spec, modelsByName, property, subSchema, visited);
     });
-    if (types_1.COMPOSED_SCHEMA_TYPES.has(model.export)) {
-        model.properties.forEach((property, i) => {
-            const subSchema = (0, refs_1.resolveIfRef)(spec, schema[(0, lodash_camelcase_1.default)(model.export)]?.[i]);
+    if (COMPOSED_SCHEMA_TYPES.has(model.export)) {
+        model.properties.forEach((property, i)=>{
+            const subSchema = resolveIfRef(spec, schema[camelCase(model.export)]?.[i]);
             if (subSchema) {
                 _ensureModelLinks(spec, modelsByName, property, subSchema, visited);
             }
@@ -611,37 +593,47 @@ const _ensureModelLinks = (spec, modelsByName, model, schema, visited) => {
  * Mutates the given data to ensure composite models (ie allOf, oneOf, anyOf) have the necessary
  * properties for representing them in generated code. Adds `composedModels` and `composedPrimitives`
  * which contain the models and primitive types that each model is composed of.
- */
-const ensureCompositeModels = (data) => {
+ */ const ensureCompositeModels = (data)=>{
     const visited = new Set();
-    data.models.forEach((model) => mutateModelWithCompositeProperties(data, model, visited));
+    data.models.forEach((model)=>mutateModelWithCompositeProperties(data, model, visited));
 };
-const mutateModelWithCompositeProperties = (data, model, visited) => {
-    if (types_1.COMPOSED_SCHEMA_TYPES.has(model.export) && !visited.has(model)) {
+const mutateModelWithCompositeProperties = (data, model, visited)=>{
+    if (COMPOSED_SCHEMA_TYPES.has(model.export) && !visited.has(model)) {
         visited.add(model);
         // Find the models/primitives which this is composed from
-        const composedModelReferences = model.properties.filter((p) => !p.name && p.export === 'reference');
-        const composedPrimitives = model.properties.filter((p) => !p.name && p.export !== 'reference');
-        const modelsByName = Object.fromEntries(data.models.map((m) => [m.name, m]));
-        let composedModels = composedModelReferences.flatMap((r) => modelsByName[r.type] ? [modelsByName[r.type]] : []);
+        const composedModelReferences = model.properties.filter((p)=>!p.name && p.export === 'reference');
+        const composedPrimitives = model.properties.filter((p)=>!p.name && p.export !== 'reference');
+        const modelsByName = Object.fromEntries(data.models.map((m)=>[
+                m.name,
+                m
+            ]));
+        let composedModels = composedModelReferences.flatMap((r)=>modelsByName[r.type] ? [
+                modelsByName[r.type]
+            ] : []);
         // Recursively resolve composed properties of properties, to ensure mixins for all-of include all recursive all-of properties
-        composedModels.forEach((m) => mutateModelWithCompositeProperties(data, m, visited));
+        composedModels.forEach((m)=>mutateModelWithCompositeProperties(data, m, visited));
         // Enums are models, however they are serialised as primitives and so should be moved to the primitives list
-        composedPrimitives.push(...composedModels.filter((m) => m.export === 'enum'));
-        composedModels = composedModels.filter((m) => m.export !== 'enum');
+        composedPrimitives.push(...composedModels.filter((m)=>m.export === 'enum'));
+        composedModels = composedModels.filter((m)=>m.export !== 'enum');
         // When multiple arrays of non-primitives are composed using allOf/oneOf/anyOf, it's not possible to distinguish at runtime which
         // type it is, and so we validate this away.
         // TODO: consider honouring more advanced OpenAPI spec features like "discriminators" which can help for this case, but in practice
         // users are unlikely to model their API this way
-        const isPrimitiveArray = (m) => {
-            if (m.link && ['array', 'dictionary'].includes(m.export)) {
-                return isPrimitiveArray((0, types_1.flattenModelLink)(m.link));
+        const isPrimitiveArray = (m)=>{
+            if (m.link && [
+                'array',
+                'dictionary'
+            ].includes(m.export)) {
+                return isPrimitiveArray(flattenModelLink(m.link));
             }
-            return (types_1.PRIMITIVE_TYPES.has(m.type) && !['date', 'date-time'].includes(m.format));
+            return PRIMITIVE_TYPES.has(m.type) && ![
+                'date',
+                'date-time'
+            ].includes(m.format);
         };
-        const arrayComposedModels = composedPrimitives.filter((m) => m.export === 'array' && !isPrimitiveArray(m));
+        const arrayComposedModels = composedPrimitives.filter((m)=>m.export === 'array' && !isPrimitiveArray(m));
         if (arrayComposedModels.length > 1) {
-            throw new Error(`Schema "${model.name}" defines ${(0, lodash_camelcase_1.default)(model.export)} with multiple array types which cannot be distinguished at runtime.`);
+            throw new Error(`Schema "${model.name}" defines ${camelCase(model.export)} with multiple array types which cannot be distinguished at runtime.`);
         }
         // For all-of models, we include all composed model properties.
         if (model.export === 'all-of') {
@@ -655,41 +647,39 @@ const mutateModelWithCompositeProperties = (data, model, visited) => {
 };
 /**
  * Mutates the given model to add language specific types and names
- */
-const mutateModelWithAdditionalTypes = (model) => {
+ */ const mutateModelWithAdditionalTypes = (model)=>{
     // Trim any surrounding quotes from name
-    model.name = (0, lodash_trim_1.default)(model.name, `"'`);
-    model.typescriptName = (0, languages_1.toTypeScriptName)(model.name);
-    model.typescriptType = (0, languages_1.toTypeScriptType)(model);
-    model.pythonName = (0, languages_1.toPythonName)('property', model.name);
-    model.pythonType = (0, languages_1.toPythonType)(model);
-    model.isPrimitive =
-        types_1.PRIMITIVE_TYPES.has(model.type) &&
-            !types_1.COMPOSED_SCHEMA_TYPES.has(model.export) &&
-            !types_1.COLLECTION_TYPES.has(model.export);
+    model.name = trim(model.name, `"'`);
+    model.typescriptName = toTypeScriptName(model.name);
+    model.typescriptType = toTypeScriptType(model);
+    model.pythonName = toPythonName('property', model.name);
+    model.pythonType = toPythonType(model);
+    model.isPrimitive = PRIMITIVE_TYPES.has(model.type) && !COMPOSED_SCHEMA_TYPES.has(model.export) && !COLLECTION_TYPES.has(model.export);
 };
 /**
  * Determine whether or not an operation is a mutation
- */
-const isOperationMutation = (op) => {
+ */ const isOperationMutation = (op)=>{
     // Let the user override whether an operation is a query or mutation using x-mutation/x-query
     const { vendorExtensions } = op;
-    if (vendorExtensions?.[types_1.VENDOR_EXTENSIONS.MUTATION]) {
+    if (vendorExtensions?.[VENDOR_EXTENSIONS.MUTATION]) {
         return true;
-    }
-    else if (vendorExtensions?.[types_1.VENDOR_EXTENSIONS.QUERY]) {
+    } else if (vendorExtensions?.[VENDOR_EXTENSIONS.QUERY]) {
         return false;
     }
     // Assume a restful API and treat mutative HTTP methods as mutations
-    return ['PATCH', 'POST', 'PUT', 'DELETE'].includes(op.method);
+    return [
+        'PATCH',
+        'POST',
+        'PUT',
+        'DELETE'
+    ].includes(op.method);
 };
 /**
  * Add infinite query details to the operation
- */
-const mutateOperationWithInfiniteQueryDetails = (op) => {
+ */ const mutateOperationWithInfiniteQueryDetails = (op)=>{
     const { paginationDisabled, cursorPropertyName } = getCursorOptions(op);
     // Allow users to customise the "cursor" property used for paginated requests
-    const cursorProperty = op.parameters.find((p) => p.name === cursorPropertyName);
+    const cursorProperty = op.parameters.find((p)=>p.name === cursorPropertyName);
     // The operation is an infinite query if:
     // - x-cursor is not set to 'false' (this allows users to disable infinite queries for operations that accept a 'cursor')
     // - the operation accepts a parameter named 'cursor', or a parameter named as the user specified with x-cursor
@@ -710,49 +700,42 @@ const mutateOperationWithInfiniteQueryDetails = (op) => {
  *
  * x-cursor: { inputToken: 'property' }
  * x-cursor: { enabled: false }
- */
-const getCursorOptions = (op) => {
+ */ const getCursorOptions = (op)=>{
     const { vendorExtensions } = op;
-    const cursorExtension = vendorExtensions?.[types_1.VENDOR_EXTENSIONS.CURSOR];
+    const cursorExtension = vendorExtensions?.[VENDOR_EXTENSIONS.CURSOR];
     // By default pagination isn't explicitly disabled and the cursor property to look for is 'cursor'
     let paginationDisabled = false;
     let cursorPropertyName = 'cursor';
     if (typeof cursorExtension === 'boolean' && cursorExtension === false) {
         paginationDisabled = true;
-    }
-    else if (typeof cursorExtension === 'string') {
+    } else if (typeof cursorExtension === 'string') {
         cursorPropertyName = cursorExtension;
-    }
-    else if (typeof cursorExtension === 'object') {
+    } else if (typeof cursorExtension === 'object') {
         if (cursorExtension?.enabled === false) {
             paginationDisabled = true;
         }
-        if (cursorExtension?.inputToken &&
-            typeof cursorExtension.inputToken === 'string') {
+        if (cursorExtension?.inputToken && typeof cursorExtension.inputToken === 'string') {
             cursorPropertyName = cursorExtension.inputToken;
         }
     }
     // x-cursor can be: a string (indicating pagination is enabled and the property name to use)
     return {
         paginationDisabled,
-        cursorPropertyName,
+        cursorPropertyName
     };
 };
 /**
  * Add additional data to an operation for code generation decisions
- */
-const mutateOperationWithAdditionalData = (op) => {
+ */ const mutateOperationWithAdditionalData = (op)=>{
     // Add mutation/query details
     const isMutation = isOperationMutation(op);
     op.isMutation = isMutation;
     op.isQuery = !isMutation;
     // Streaming responses
-    op.isStreaming =
-        !!op.vendorExtensions?.[types_1.VENDOR_EXTENSIONS.STREAMING] ||
-            op.responses.some((res) => res.isJsonlStreaming);
+    op.isStreaming = !!op.vendorExtensions?.[VENDOR_EXTENSIONS.STREAMING] || op.responses.some((res)=>res.isJsonlStreaming);
     // Set the result type for the client method to the item schema so that
     // it will resolve to AsyncIterableIterator<{itemSchemaModel.name}>
-    const jsonlResponse = op.responses.find((res) => res.isJsonlStreaming);
+    const jsonlResponse = op.responses.find((res)=>res.isJsonlStreaming);
     if (jsonlResponse) {
         const itemSchemaModel = jsonlResponse.itemSchemaModel;
         const result = op.result;
@@ -767,4 +750,5 @@ const mutateOperationWithAdditionalData = (op) => {
         mutateOperationWithInfiniteQueryDetails(op);
     }
 };
+
 //# sourceMappingURL=codegen-data.js.map