@azure-tools/typespec-ts 0.53.3 → 0.54.0

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

@@ -0,0 +1,144 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import { RLCModel } from "../interfaces.js";
+import { NameType, normalizeName } from "./nameUtils.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/nameUtils.ts

@@ -0,0 +1,319 @@
+// 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/operationHelpers.ts

@@ -0,0 +1,155 @@
+// 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 "./nameUtils.js";
+import { isObjectSchema } from "./schemaHelpers.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/packageUtil.ts

@@ -0,0 +1,13 @@
+import { RLCModel, RLCOptions } from "../interfaces.js";
+
+export function isAzurePackage(model: { options?: RLCOptions }): boolean {
+  return Boolean(model.options?.flavor === "azure");
+}
+
+export function isAzureMonorepoPackage(model: RLCModel): boolean {
+  return Boolean(model.options?.azureSdkForJs) && isAzurePackage(model);
+}
+
+export function isAzureStandalonePackage(model: RLCModel): boolean {
+  return isAzurePackage(model) && !model.options?.azureSdkForJs;
+}

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

@@ -0,0 +1,15 @@
+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/schemaHelpers.ts

@@ -0,0 +1,61 @@
+// 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;
+}