@azure-tools/typespec-ts 0.54.0 → 0.54.2

package/src/rlc-common/helpers/name-constructors.ts

@@ -0,0 +1,110 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import { RLCModel } from "../interfaces.js";
+import { NameType, normalizeName } from "./name-utils.js";
+
+/**
+ * Get the response type name by baseName or operatioName & statusCode
+ * @param baseResponseName
+ */
+export function getResponseTypeName(baseResponseName: string): string;
+export function getResponseTypeName(
+  operationGroup: string,
+  operationName: string,
+  statusCode: string,
+): string;
+export function getResponseTypeName(
+  baseNameOrOperationGroup: string,
+  operationName?: string,
+  statusCode?: string,
+): string {
+  if (operationName) {
+    baseNameOrOperationGroup = getResponseBaseName(
+      baseNameOrOperationGroup,
+      operationName!,
+      statusCode || "",
+    );
+  }
+  return normalizeName(`${baseNameOrOperationGroup}Response`, NameType.Interface);
+}
+
+export function getLroLogicalResponseName(operationGroup: string, operationName: string) {
+  return normalizeName(`${operationGroup}_${operationName}_Logical_Response`, NameType.Interface);
+}
+
+/**
+ * The prefix of all response types
+ * @param operationGroup operation group name e.g string_PutEmpty
+ * @param operationName operation name D e.g string_PutEmpty
+ * @param statusCode 2XX, 4XX, 5XX, default etc.
+ * @returns normolized base name e.g StringPutEmpty200
+ */
+export function getResponseBaseName(
+  operationGroup: string,
+  operationName: string,
+  statusCode: string,
+) {
+  return normalizeName(
+    `${operationGroup}_${normalizeName(operationName, NameType.Interface, true)}_${statusCode}`,
+    NameType.Interface,
+  );
+}
+
+/**
+ * The prefix of all parameter relevant types
+ * @param operationName is composed with operationGroup and operationID e.g string_PutEmpty
+ * @returns
+ */
+export function getParameterBaseName(operationGroup: string, operationName: string) {
+  return normalizeName(`${operationGroup}_${operationName}`, NameType.Interface);
+}
+
+/**
+ * Get the top-layer parameter name
+ * @param operationGroup operation group name
+ * @param operationName is composed with operationGroup and operationID e.g string_PutEmpty
+ * @returns top-layer parameter name e.g StringPutEmptParameters
+ */
+export function getParameterTypeName(baseName: string): string;
+export function getParameterTypeName(operationGroup: string, operationName: string): string;
+export function getParameterTypeName(baseNameOrOperationGroup: string, operationName?: string) {
+  if (operationName) {
+    baseNameOrOperationGroup = getParameterBaseName(baseNameOrOperationGroup, operationName!);
+  }
+
+  return normalizeName(`${baseNameOrOperationGroup}_Parameters`, NameType.Interface);
+}
+
+export interface ModuleName {
+  esModulesName: string;
+  cjsName: string;
+}
+/**
+ * This is a helper function that gets the right import module depending on the type of
+ * library being generated
+ */
+export function getImportModuleName(name: ModuleName, codeModel: RLCModel) {
+  if (codeModel.options?.moduleKind === "cjs") {
+    return name.cjsName;
+  }
+  return name.esModulesName;
+}
+
+export function getClientName(model: RLCModel) {
+  const clientName = model.libraryName;
+  const clientInterfaceName = model.options?.isModularLibrary
+    ? model.libraryName
+    : clientName.endsWith("Client")
+      ? `${clientName}`
+      : `${clientName}Client`;
+
+  return clientInterfaceName;
+}
+
+export function getMultipartPartTypeName(schemaName: string, partName: string) {
+  const name = normalizeName(partName, NameType.Interface);
+  const bodyParamName = normalizeName(schemaName, NameType.Interface);
+
+  return normalizeName(`${bodyParamName}_${name}_PartDescriptor`, NameType.Interface);
+}

package/src/rlc-common/helpers/name-utils.ts

@@ -0,0 +1,296 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+export interface NormalizeNameOption {
+  shouldGuard?: boolean;
+  customReservedNames?: ReservedName[];
+  casingOverride?: CasingConvention;
+  numberPrefixOverride?: string;
+}
+
+export interface ReservedName {
+  name: string;
+  reservedFor: NameType[];
+}
+
+export enum NameType {
+  Class,
+  File,
+  Interface,
+  Property,
+  Parameter,
+  Operation,
+  OperationGroup,
+  Method,
+  EnumMemberName,
+}
+
+const Newable = [NameType.Class, NameType.Interface, NameType.OperationGroup];
+
+export const ReservedModelNames: ReservedName[] = [
+  { name: "any", reservedFor: [NameType.Parameter] },
+  { name: "as", reservedFor: [NameType.Parameter] },
+  { name: "assert", reservedFor: [NameType.Parameter] },
+  { name: "async", reservedFor: [NameType.Parameter] },
+  { name: "await", reservedFor: [NameType.Parameter, NameType.Method] },
+  { name: "boolean", reservedFor: [NameType.Parameter, ...Newable] },
+  { name: "break", reservedFor: [NameType.Parameter, NameType.Method] },
+  { name: "case", reservedFor: [NameType.Parameter, NameType.Method] },
+  { name: "catch", reservedFor: [NameType.Parameter, NameType.Method] },
+  { name: "class", reservedFor: [NameType.Parameter, NameType.Method] },
+  { name: "const", reservedFor: [NameType.Parameter, NameType.Method] },
+  { name: "constructor", reservedFor: [NameType.Parameter] },
+  { name: "continue", reservedFor: [NameType.Parameter, NameType.Method] },
+  { name: "date", reservedFor: [NameType.Parameter, ...Newable] },
+  { name: "debugger", reservedFor: [NameType.Parameter, NameType.Method] },
+  { name: "declare", reservedFor: [NameType.Parameter] },
+  { name: "default", reservedFor: [NameType.Parameter, NameType.Method] },
+  {
+    name: "delete",
+    reservedFor: [NameType.Parameter, NameType.Operation, NameType.Method],
+  },
+  { name: "do", reservedFor: [NameType.Parameter, NameType.Method] },
+  { name: "else", reservedFor: [NameType.Parameter, NameType.Method] },
+  { name: "enum", reservedFor: [NameType.Parameter, NameType.Method] },
+  { name: "error", reservedFor: [NameType.Parameter, ...Newable] },
+  {
+    name: "export",
+    reservedFor: [NameType.Parameter, NameType.Operation, NameType.Method],
+  },
+  { name: "extends", reservedFor: [NameType.Parameter, NameType.Method] },
+  { name: "false", reservedFor: [NameType.Parameter, NameType.Method] },
+  { name: "finally", reservedFor: [NameType.Parameter, NameType.Method] },
+  { name: "for", reservedFor: [NameType.Parameter, NameType.Method] },
+  { name: "from", reservedFor: [NameType.Parameter] },
+  {
+    name: "function",
+    reservedFor: [NameType.Parameter, ...Newable, NameType.Method],
+  },
+  { name: "get", reservedFor: [NameType.Parameter] },
+  { name: "if", reservedFor: [NameType.Parameter, NameType.Method] },
+  { name: "implements", reservedFor: [NameType.Parameter] },
+  { name: "import", reservedFor: [NameType.Parameter, NameType.Method] },
+  { name: "in", reservedFor: [NameType.Parameter, NameType.Method] },
+  { name: "instanceof", reservedFor: [NameType.Parameter, NameType.Method] },
+  { name: "interface", reservedFor: [NameType.Parameter] },
+  { name: "let", reservedFor: [NameType.Parameter, NameType.Method] },
+  { name: "module", reservedFor: [NameType.Parameter] },
+  { name: "new", reservedFor: [NameType.Parameter, NameType.Method] },
+  { name: "null", reservedFor: [NameType.Parameter, NameType.Method] },
+  { name: "number", reservedFor: [NameType.Parameter, ...Newable] },
+  { name: "of", reservedFor: [NameType.Parameter] },
+  { name: "package", reservedFor: [NameType.Parameter] },
+  { name: "private", reservedFor: [NameType.Parameter] },
+  { name: "protected", reservedFor: [NameType.Parameter] },
+  {
+    name: "public",
+    reservedFor: [NameType.Parameter, NameType.Operation, NameType.Method],
+  },
+  { name: "requestoptions", reservedFor: [NameType.Parameter] },
+  { name: "require", reservedFor: [NameType.Parameter, NameType.Method] },
+  { name: "return", reservedFor: [NameType.Parameter, NameType.Method] },
+  { name: "set", reservedFor: [NameType.Parameter, ...Newable] },
+  { name: "static", reservedFor: [NameType.Parameter, NameType.Method] },
+  { name: "string", reservedFor: [NameType.Parameter, ...Newable] },
+  { name: "super", reservedFor: [NameType.Parameter, NameType.Method] },
+  { name: "switch", reservedFor: [NameType.Parameter, NameType.Method] },
+  { name: "symbol", reservedFor: [NameType.Parameter, ...Newable] },
+  { name: "this", reservedFor: [NameType.Parameter, NameType.Method] },
+  { name: "throw", reservedFor: [NameType.Parameter, NameType.Method] },
+  { name: "true", reservedFor: [NameType.Parameter, NameType.Method] },
+  { name: "try", reservedFor: [NameType.Parameter, NameType.Method] },
+  { name: "type", reservedFor: [NameType.Parameter] },
+  { name: "typeof", reservedFor: [NameType.Parameter, NameType.Method] },
+  { name: "var", reservedFor: [NameType.Parameter, NameType.Method] },
+  { name: "void", reservedFor: [NameType.Parameter, NameType.Method] },
+  { name: "while", reservedFor: [NameType.Parameter, NameType.Method] },
+  { name: "with", reservedFor: [NameType.Parameter, NameType.Method] },
+  { name: "yield", reservedFor: [NameType.Parameter, NameType.Method] },
+  { name: "arguments", reservedFor: [NameType.Parameter, NameType.Method] },
+  { name: "global", reservedFor: [...Newable] },
+  // reserve client for codegen
+  { name: "client", reservedFor: [NameType.Parameter] },
+  { name: "endpoint", reservedFor: [NameType.Parameter] },
+  { name: "apiVersion", reservedFor: [NameType.Parameter] },
+];
+
+export enum CasingConvention {
+  Pascal,
+  Camel,
+}
+
+export function guardReservedNames(
+  name: string,
+  nameType: NameType,
+  customReservedNames: ReservedName[] = [],
+): string {
+  const [prefix, suffix] = getAffix(nameType);
+  return [...ReservedModelNames, ...customReservedNames]
+    .filter((r) => r.reservedFor.includes(nameType))
+    .find((r) => r.name === name.toLowerCase())
+    ? `${prefix}${name}${suffix}`
+    : name;
+}
+
+function getAffix(nameType?: NameType): [string, string] {
+  switch (nameType) {
+    case NameType.File:
+    case NameType.Operation:
+      return ["", ""];
+    case NameType.Property:
+      return ["", "Property"];
+    case NameType.OperationGroup:
+      return ["", "Operations"];
+    case NameType.Parameter:
+      return ["", "Param"];
+    case NameType.Method:
+      return ["$", ""];
+    case NameType.Class:
+    case NameType.Interface:
+    default:
+      return ["", "Model"];
+  }
+}
+
+export function normalizeName(
+  name: string,
+  nameType: NameType,
+  shouldGuard?: boolean,
+  customReservedNames?: ReservedName[],
+  casingOverride?: CasingConvention,
+  oriName?: string,
+): string;
+export function normalizeName(
+  name: string,
+  nameType: NameType,
+  options?: NormalizeNameOption,
+): string;
+export function normalizeName(
+  name: string,
+  nameType: NameType,
+  optionsOrShouldGuard?: NormalizeNameOption | boolean,
+  optionalCustomReservedNames?: ReservedName[],
+  optionalCasingOverride?: CasingConvention,
+  oriName?: string,
+): string {
+  let shouldGuard: boolean | undefined,
+    customReservedNames: ReservedName[],
+    casingOverride: CasingConvention | undefined,
+    numberPrefixOverride: string | undefined;
+  if (typeof optionsOrShouldGuard === "boolean") {
+    shouldGuard = optionsOrShouldGuard;
+    customReservedNames = optionalCustomReservedNames ?? [];
+    casingOverride = optionalCasingOverride;
+  } else {
+    shouldGuard = optionsOrShouldGuard?.shouldGuard;
+    customReservedNames = optionsOrShouldGuard?.customReservedNames ?? [];
+    casingOverride = optionsOrShouldGuard?.casingOverride;
+    numberPrefixOverride = optionsOrShouldGuard?.numberPrefixOverride;
+  }
+  if ((oriName ?? name).startsWith("$DO_NOT_NORMALIZE$")) {
+    return (oriName ?? name).replace("$DO_NOT_NORMALIZE$", "");
+  }
+  const casingConvention = casingOverride ?? getCasingConvention(nameType);
+  const parts = deconstruct(name);
+  if (parts.length === 0) {
+    return name;
+  }
+  const [firstPart, ...otherParts] = parts;
+  const normalizedFirstPart = toCasing(firstPart ?? "", casingConvention, true);
+  const normalizedParts = (otherParts || [])
+    .map((part) => toCasing(part, CasingConvention.Pascal))
+    .join("");
+
+  const normalized = `${normalizedFirstPart}${normalizedParts}`;
+  const result = shouldGuard
+    ? guardReservedNames(normalized, nameType, customReservedNames)
+    : normalized;
+  return fixLeadingNumber(result, nameType, numberPrefixOverride);
+}
+
+export function fixLeadingNumber(name: string, nameType: NameType, prefix: string = "_"): string {
+  const casingConvention = getCasingConvention(nameType);
+  if (!name || !name.match(/^[-.]?\d/)) {
+    return name;
+  }
+  return `${toCasing(prefix, casingConvention)}${name}`;
+}
+
+function isFullyUpperCase(identifier: string, maxUppercasePreserve: number = 3) {
+  const len = identifier.length;
+  if (len > 1) {
+    if (len <= maxUppercasePreserve && identifier === identifier.toUpperCase()) {
+      return true;
+    }
+
+    if (len <= maxUppercasePreserve + 1 && identifier.endsWith("s")) {
+      const i = identifier.substring(0, len - 1);
+      if (i.toUpperCase() === i) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+function deconstruct(identifier: string): Array<string> {
+  return `${identifier}`
+    .replace(/([a-z]+)([A-Z])/g, "$1 $2") // Add a space in between camelCase words(e.g. fooBar => foo Bar)
+    .replace(/(\d+)/g, " $1 ") // Adds a space after numbers(e.g. foo123Bar => foo123 bar)
+    .replace(/_/g, " ") // Replace underscores with spaces
+    .replace(/\b([A-Z]+)([A-Z])s([^a-z])(.*)/g, "$1$2« $3$4") // Add a space after a plural upper cased word(e.g. MBsFoo => MBs Foo)
+    .replace(/\b([A-Z]+)([A-Z])([a-z]+)/g, "$1 $2$3") // Add a space between an upper case word(2 char+) and the last captial case.(e.g. SQLConnection -> SQL Connection)
+    .replace(/«/g, "s")
+    .trim()
+    .split(/[\W|_]+/)
+    .map((each) => (isFullyUpperCase(each) ? each : each.toLowerCase()))
+    .filter((part) => !!part);
+}
+
+export function getModelsName(title: string): string {
+  const spaceRemovedTitle = title.replace(/ /g, "");
+  return `${spaceRemovedTitle.replace("Client", "")}Models`;
+}
+
+export function getMappersName(title: string): string {
+  const spaceRemovedTitle = title.replace(/ /g, "");
+  return `${spaceRemovedTitle.replace("Client", "")}Mappers`;
+}
+
+function getCasingConvention(nameType: NameType) {
+  switch (nameType) {
+    case NameType.Class:
+    case NameType.Interface:
+    case NameType.OperationGroup:
+    case NameType.EnumMemberName:
+      return CasingConvention.Pascal;
+    case NameType.File:
+    case NameType.Property:
+    case NameType.Operation:
+    case NameType.Parameter:
+    case NameType.Method:
+      return CasingConvention.Camel;
+  }
+}
+
+function toCasing(str: string, casing: CasingConvention, keepConsistent = false): string {
+  const firstChar =
+    casing === CasingConvention.Pascal ? str.charAt(0).toUpperCase() : str.charAt(0).toLowerCase();
+  const allLowerCases =
+    casing !== CasingConvention.Pascal && keepConsistent && str.toUpperCase() === str;
+  return allLowerCases ? str.toLowerCase() : `${firstChar}${str.substring(1)}`;
+}
+
+export function pascalCase(str: string) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+export function camelCase(str: string, options: { uppercaseThreshold?: number } = {}) {
+  const { uppercaseThreshold = 4 } = options;
+  const thresholdRegex = new RegExp(`^(?<![A-Z])[A-Z]{1,${uppercaseThreshold}}(?![A-Z])`);
+  if (!thresholdRegex.test(str)) {
+    return str;
+  }
+
+  return str.charAt(0).toLowerCase() + str.slice(1);
+}

package/src/rlc-common/helpers/operation-helpers.ts

@@ -0,0 +1,138 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import { MethodSignatureStructure, OptionalKind, ParameterDeclarationStructure } from "ts-morph";
+import {
+  Methods,
+  ObjectSchema,
+  ParameterMetadata,
+  PathParameter,
+  RLCModel,
+  Schema,
+  SchemaContext,
+} from "../interfaces.js";
+import { NameType, normalizeName, pascalCase } from "./name-utils.js";
+import { isObjectSchema } from "./schema-helpers.js";
+
+export function buildMethodDefinitions(
+  methods: Methods,
+  pathParams: PathParameter[] = [],
+): OptionalKind<MethodSignatureStructure>[] {
+  const methodDefinitions: OptionalKind<MethodSignatureStructure>[] = [];
+  for (const key of Object.keys(methods)) {
+    const verbMethods = methods[key];
+    if (!verbMethods) {
+      continue;
+    }
+    for (const method of verbMethods) {
+      const description = method.description;
+      const areAllOptional = method.hasOptionalOptions;
+
+      methodDefinitions.push({
+        name: key,
+        ...(description && { docs: [{ description }] }),
+        parameters: [
+          ...getPathParamDefinitions(pathParams),
+          {
+            name: "options",
+            hasQuestionToken: areAllOptional,
+            type: pascalCase(method.optionsName),
+          },
+        ],
+        returnType: `StreamableMethod<${method.returnType}>`,
+      });
+    }
+  }
+
+  return methodDefinitions;
+}
+
+export function getPathParamDefinitions(
+  pathParams: PathParameter[],
+): OptionalKind<ParameterDeclarationStructure>[] {
+  return pathParams.map(({ name, type, description }) => {
+    return {
+      name: normalizeName(name, NameType.Parameter),
+      type,
+      description,
+    };
+  });
+}
+
+export function hasPagingOperations(model: RLCModel) {
+  return Boolean(model.helperDetails?.hasPaging);
+}
+
+export function hasPollingOperations(model: RLCModel) {
+  return Boolean(model.helperDetails?.hasLongRunning);
+}
+
+export function hasMultiCollection(model: RLCModel) {
+  return Boolean(model.helperDetails?.hasMultiCollection);
+}
+
+export function hasPipeCollection(model: RLCModel) {
+  return Boolean(model.helperDetails?.hasPipeCollection);
+}
+
+export function hasSsvCollection(model: RLCModel) {
+  return Boolean(model.helperDetails?.hasSsvCollection);
+}
+
+export function hasTsvCollection(model: RLCModel) {
+  return Boolean(model.helperDetails?.hasTsvCollection);
+}
+
+export function hasCsvCollection(model: RLCModel) {
+  return Boolean(model.helperDetails?.hasCsvCollection);
+}
+
+export function hasUnexpectedHelper(model: RLCModel) {
+  const pathDictionary = model.paths;
+  for (const details of Object.values(pathDictionary)) {
+    for (const methodDetails of Object.values(details.methods)) {
+      const firstMethod = methodDetails[0];
+      if (!firstMethod) {
+        continue;
+      }
+      const successTypes = firstMethod.responseTypes.success;
+      const errorTypes = firstMethod.responseTypes.error;
+
+      if (successTypes.length > 0 && errorTypes.length > 0 && !!errorTypes[0]) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+export function hasInputModels(model: RLCModel) {
+  return hasSchemaContextObject(model, [SchemaContext.Input]);
+}
+export function hasOutputModels(model: RLCModel) {
+  return hasSchemaContextObject(model, [SchemaContext.Output, SchemaContext.Exception]);
+}
+
+function hasSchemaContextObject(model: RLCModel, schemaUsage: SchemaContext[]) {
+  const objectSchemas: ObjectSchema[] = (model.schemas ?? []).filter(
+    (o) => isObjectSchema(o) && (o as ObjectSchema).usage?.some((u) => schemaUsage.includes(u)),
+  );
+
+  return objectSchemas.length > 0;
+}
+
+export function getGeneratedWrapperTypes(params: ParameterMetadata[] | PathParameter[]): Schema[] {
+  const wrapperTypes = params
+    .map((qp) => (isParameterMetadata(qp) ? qp.param.wrapperType : qp.wrapperType))
+    .filter((v) => v !== undefined);
+  const wrapperFromObjects = wrapperTypes.filter((wrap) => wrap.type === "object");
+  const wrapperFromUnions = wrapperTypes
+    .filter((wrap) => wrap.type === "union")
+    .flatMap((wrapperType) => wrapperType?.enum ?? [])
+    .filter((v) => v.type === "object");
+  return [...wrapperFromUnions, ...wrapperFromObjects];
+}
+
+function isParameterMetadata(param: ParameterMetadata | PathParameter): param is ParameterMetadata {
+  return (param as any).param !== undefined;
+}

package/src/rlc-common/helpers/path-utils.ts

@@ -0,0 +1,10 @@
+import * as path from "path";
+
+export function getRelativePartFromSrcPath(srcPath: string, isModularLibrary: boolean = false) {
+  const sep = srcPath.includes(path.sep + "src") ? path.sep : "/";
+  let relativePart = srcPath.substring(srcPath.indexOf(sep + "src") + 4);
+  if (isModularLibrary) {
+    relativePart = relativePart.substring(srcPath.indexOf(sep + "rest"), +5);
+  }
+  return relativePart.startsWith(sep) ? relativePart.substring(1) : relativePart;
+}

package/src/rlc-common/helpers/schema-helpers.ts

@@ -0,0 +1,50 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import { ArraySchema, ObjectSchema, RLCModel, Schema, SchemaContext } from "../interfaces.js";
+
+export interface IsDictionaryOptions {
+  filterEmpty?: boolean;
+}
+
+export function isArraySchema(schema: Schema): schema is ArraySchema {
+  return schema.type === "array" || typeof (schema as any).items !== "undefined";
+}
+
+export function isDictionarySchema(schema: Schema, options: IsDictionaryOptions = {}) {
+  if (schema.type === "dictionary") {
+    if (!options.filterEmpty || (options.filterEmpty && !schema.typeName)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+export function isObjectSchema(schema: Schema): schema is ObjectSchema {
+  if (schema.type === "object") {
+    return true;
+  }
+  return false;
+}
+
+export function isConstantSchema(schema: Schema) {
+  if (schema.type === "constant") {
+    return true;
+  }
+  return false;
+}
+
+export function buildSchemaObjectMap(model: RLCModel) {
+  // include interfaces
+  const map = new Map<string, Schema>();
+  const allSchemas = (model.schemas ?? []).filter(
+    (o) =>
+      isObjectSchema(o) &&
+      (o as ObjectSchema).usage?.some((u) => [SchemaContext.Input].includes(u)),
+  );
+  allSchemas.forEach((o) => {
+    map.set(o.name, o);
+  });
+
+  return map;
+}

package/src/rlc-common/helpers/shortcut-methods.ts

@@ -0,0 +1,58 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import { InterfaceDeclarationStructure, MethodSignatureStructure, OptionalKind } from "ts-morph";
+import { PathMetadata, Paths } from "../interfaces.js";
+import { NameType, normalizeName } from "./name-utils.js";
+import { buildMethodDefinitions } from "./operation-helpers.js";
+
+export function generateMethodShortcuts(
+  paths: Paths,
+): OptionalKind<InterfaceDeclarationStructure>[] {
+  const keys: Record<string, OptionalKind<MethodSignatureStructure>[]> = {};
+  for (const path in paths) {
+    const pathMetadata = paths[path];
+    if (!pathMetadata) {
+      continue;
+    }
+    const groupName = pathMetadata.operationGroupName;
+    const definitions = buildOperationDefinitions(pathMetadata);
+    if (!keys[groupName]) {
+      keys[groupName] = definitions;
+    } else {
+      keys[groupName] = [...keys[groupName], ...definitions];
+    }
+  }
+
+  const interfaces: OptionalKind<InterfaceDeclarationStructure>[] = [];
+
+  for (const interfaceName in keys) {
+    const methods = keys[interfaceName];
+    interfaces.push({
+      name: `${interfaceName}Operations`,
+      methods: methods,
+      isExported: true,
+      docs: [`Contains operations for ${interfaceName} operations`],
+    });
+  }
+
+  return interfaces;
+}
+
+function buildOperationDefinitions(path: PathMetadata): OptionalKind<MethodSignatureStructure>[] {
+  let ops: OptionalKind<MethodSignatureStructure>[] = [];
+
+  for (const verb in path.methods) {
+    const methods = path.methods[verb];
+    if (!methods) {
+      continue;
+    }
+    for (const method of methods) {
+      const name = normalizeName(method.operationName, NameType.Property);
+      const pathParams = path.pathParameters;
+      const methodDefinitions = buildMethodDefinitions({ [name]: [method] }, pathParams);
+      ops = [...ops, ...methodDefinitions];
+    }
+  }
+  return ops;
+}