fern-api 0.41.0-rc1 → 0.41.0

package/bundle.cjs

@@ -1208726,7 +1208726,7 @@ var AccessTokenPosthogManager = class {
         properties: {
           ...event,
           ...event.properties,
-          version: "0.41.0-rc1",
+          version: "0.41.0",
           usingAccessToken: true
         }
       });
@@ -1208788,7 +1208788,7 @@ var UserPosthogManager = class {
       distinctId: this.userId ?? await this.getPersistedDistinctId(),
       event: "CLI",
       properties: {
-        version: "0.41.0-rc1",
+        version: "0.41.0",
         ...event,
         ...event.properties
       }
@@ -1213878,10 +1213878,10 @@ var CliContext = class {
     return "fern-api";
   }
   getPackageVersion() {
-    if ("0.41.0-rc1" == null) {
+    if ("0.41.0" == null) {
       this.logger.error("CLI_VERSION is not defined");
     }
-    return "0.41.0-rc1";
+    return "0.41.0";
   }
   getCliName() {
     if ("fern" == null) {
@@ -1215080,6 +1215080,33 @@ var RootApiFileSchema = z.strictObject({
   version: z.optional(VersionDeclarationSchema)
 });
 
+// ../fern-definition/schema/lib/utils/RawContainerType.js
+var RawContainerType = {
+  optional: "optional",
+  set: "set",
+  list: "list",
+  map: "map",
+  literal: "literal"
+};
+var RawContanerTypes = new Set(Object.values(RawContainerType));
+
+// ../fern-definition/schema/lib/utils/generics/parseGeneric.js
+function parseGeneric(name2) {
+  const genericMatch = name2.match(/([\w.]+)<([\w,\s]+)>/);
+  if ((genericMatch == null ? void 0 : genericMatch[0]) != null && genericMatch[1] != null && genericMatch[2] != null && !RawContanerTypes.has(genericMatch[1].trim())) {
+    return {
+      name: genericMatch[1].trim(),
+      arguments: genericMatch[2].split(",").map((arg) => arg.trim())
+    };
+  }
+  return void 0;
+}
+
+// ../fern-definition/schema/lib/utils/generics/isGeneric.js
+function isGeneric(name2) {
+  return parseGeneric(name2) != null;
+}
+
 // ../fern-definition/schema/lib/utils/getRequestBody.js
 function getRequestBody(endpoint) {
   if (endpoint.request == null) {
@@ -1257323,9 +1257350,44 @@ function maybeConvertWellKnownProtobufType({ type: type2 }) {
   return void 0;
 }
 
+// ../generation/ir-generator/lib/converters/type-declarations/convertGenericTypeDeclaration.js
+async function convertGenericTypeDeclaration({ generic, file, typeResolver }) {
+  var _a6;
+  const genericInstantiation = typeof generic === "string" ? generic : generic.type;
+  const maybeGeneric = parseGeneric(genericInstantiation);
+  if (maybeGeneric == null) {
+    throw new Error(`Invalid generic type definition: ${genericInstantiation}`);
+  }
+  const resolvedBaseGeneric = typeResolver.getDeclarationOfNamedTypeOrThrow({
+    referenceToNamedType: genericInstantiation,
+    file
+  });
+  if (maybeGeneric.arguments && isRawObjectDefinition(resolvedBaseGeneric.declaration)) {
+    const genericArgumentDefinitions = ((_a6 = parseGeneric(resolvedBaseGeneric.typeName)) == null ? void 0 : _a6.arguments) ?? [];
+    const newProperties = Object.entries(resolvedBaseGeneric.declaration.properties ?? {}).map(([key, value]) => {
+      var _a7;
+      let maybeReplacedValue = value;
+      if (typeof value === "string" && (genericArgumentDefinitions == null ? void 0 : genericArgumentDefinitions.includes(value))) {
+        maybeReplacedValue = ((_a7 = maybeGeneric.arguments) == null ? void 0 : _a7[genericArgumentDefinitions.indexOf(value)]) ?? value;
+      }
+      return [key, maybeReplacedValue];
+    });
+    return Type2.object({
+      extends: getExtensionsAsList(resolvedBaseGeneric.declaration.extends).map((extended) => parseTypeName({ typeName: extended, file })),
+      properties: await getObjectPropertiesFromRawObjectSchema({ properties: Object.fromEntries(newProperties) }, file),
+      extraProperties: resolvedBaseGeneric.declaration["extra-properties"] ?? false,
+      extendedProperties: void 0
+    });
+  }
+  throw new Error(`Generic type definition not supported: ${genericInstantiation}`);
+}
+
 // ../generation/ir-generator/lib/converters/type-declarations/convertAliasTypeDeclaration.js
-function convertAliasTypeDeclaration({ alias, file, typeResolver }) {
+async function convertAliasTypeDeclaration({ alias, file, typeResolver }) {
   const aliasOfStr = typeof alias === "string" ? alias : alias.type;
+  if (isGeneric(aliasOfStr)) {
+    return await convertGenericTypeDeclaration({ generic: aliasOfStr, file, typeResolver });
+  }
   return Type2.alias({
     aliasOf: file.parseTypeReference(alias),
     resolvedType: constructResolvedTypeReference({ aliasOf: aliasOfStr, file, typeResolver })
@@ -1257369,22 +1257431,41 @@ function convertUndiscriminatedUnionTypeDeclaration({ union: union4, file }) {
 }
 
 // ../generation/ir-generator/lib/converters/type-declarations/getReferencedTypesFromRawDeclaration.js
+function getObjectRawTypeReferences(objectDeclaration) {
+  const types3 = [];
+  if (objectDeclaration.extends != null) {
+    const extendsArr = typeof objectDeclaration.extends === "string" ? [objectDeclaration.extends] : objectDeclaration.extends;
+    types3.push(...extendsArr);
+  }
+  if (objectDeclaration.properties != null) {
+    types3.push(...Object.values(objectDeclaration.properties).map((property5) => typeof property5 === "string" ? property5 : property5.type));
+  }
+  return types3;
+}
 function getReferencedTypesFromRawDeclaration({ typeDeclaration, file, typeResolver, seenTypeNames = new SeenTypeNamesImpl() }) {
   const rawTypeReferences = visitRawTypeDeclaration(typeDeclaration, {
     alias: (aliasDeclaration) => {
-      return [typeof aliasDeclaration === "string" ? aliasDeclaration : aliasDeclaration.type];
-    },
-    object: (objectDeclaration) => {
-      const types3 = [];
-      if (objectDeclaration.extends != null) {
-        const extendsArr = typeof objectDeclaration.extends === "string" ? [objectDeclaration.extends] : objectDeclaration.extends;
-        types3.push(...extendsArr);
-      }
-      if (objectDeclaration.properties != null) {
-        types3.push(...Object.values(objectDeclaration.properties).map((property5) => typeof property5 === "string" ? property5 : property5.type));
+      var _a6;
+      const aliasTypeReference = typeof aliasDeclaration === "string" ? aliasDeclaration : aliasDeclaration.type;
+      const parsedGeneric = parseGeneric(aliasTypeReference);
+      if (parsedGeneric != null) {
+        const rawTypeReferences2 = new Set(parsedGeneric.arguments ?? []);
+        const resolvedBaseGeneric = typeResolver.getDeclarationOfNamedTypeOrThrow({
+          referenceToNamedType: aliasTypeReference,
+          file
+        });
+        const resolvedBaseGenericArguments = (_a6 = parseGeneric(resolvedBaseGeneric.typeName)) == null ? void 0 : _a6.arguments;
+        if (isRawObjectDefinition(resolvedBaseGeneric.declaration)) {
+          const underlyingObjectRawTypeReferences = getObjectRawTypeReferences(resolvedBaseGeneric.declaration);
+          if (resolvedBaseGenericArguments) {
+            underlyingObjectRawTypeReferences.filter((typeReference) => !resolvedBaseGenericArguments.includes(typeReference)).forEach((type2) => rawTypeReferences2.add(type2));
+          }
+        }
+        return Array.from(rawTypeReferences2);
       }
-      return types3;
+      return [aliasTypeReference];
     },
+    object: (objectDeclaration) => getObjectRawTypeReferences(objectDeclaration),
     discriminatedUnion: (unionDeclaration) => {
       const types3 = [];
       if (unionDeclaration["base-properties"] != null) {
@@ -1257436,6 +1257517,9 @@ function getReferencedTypesFromRawDeclaration({ typeDeclaration, file, typeResol
           referenceToNamedType: rawName,
           file
         });
+        if (isGeneric(maybeDeclaration.typeName)) {
+          continue;
+        }
         referencedTypes.push(...getReferencedTypesFromRawDeclaration({
           typeDeclaration: maybeDeclaration.declaration,
           file: maybeDeclaration.file,
@@ -1259904,7 +1259988,7 @@ var TypeResolverImpl = class {
     return declaration;
   }
   getDeclarationOfNamedType({ referenceToNamedType, file }) {
-    var _a6;
+    var _a6, _b4;
     const parsedReference = parseReferenceToTypeName({
       reference: referenceToNamedType,
       referencedIn: file.relativeFilepath,
@@ -1259919,6 +1260003,24 @@ var TypeResolverImpl = class {
     }
     const declaration = (_a6 = definitionFile.types) == null ? void 0 : _a6[parsedReference.typeName];
     if (declaration == null) {
+      const parsedGeneric = parseGeneric(parsedReference.typeName);
+      if (parsedGeneric != null) {
+        for (const type2 of Object.keys(definitionFile.types ?? {}) ?? []) {
+          if (parsedGeneric.name && type2.startsWith(parsedGeneric.name) && type2.endsWith(">")) {
+            const genericDeclaration = (_b4 = definitionFile.types) == null ? void 0 : _b4[type2];
+            return genericDeclaration != null ? {
+              typeName: type2,
+              declaration: genericDeclaration,
+              file: constructFernFileContext({
+                relativeFilepath: parsedReference.relativeFilepath,
+                definitionFile,
+                casingsGenerator: file.casingsGenerator,
+                rootApiFile: this.workspace.definition.rootApiFile.contents
+              })
+            } : void 0;
+          }
+        }
+      }
       return void 0;
     }
     return {
@@ -1260211,6 +1260313,9 @@ async function generateIntermediateRepresentation({ fdrApiDefinitionId, workspac
           return;
         }
         for (const [typeName, typeDeclaration] of Object.entries(types4)) {
+          if (isGeneric(typeName)) {
+            continue;
+          }
           const convertedTypeDeclarationWithFilepaths = await convertTypeDeclaration({
             typeName,
             typeDeclaration,
@@ -1265234,7 +1265339,8 @@ function createTypeReferenceVisitor(visitor) {
       typeReference,
       _default: _default2,
       validation,
-      location: location3
+      location: location3,
+      nodePath
     }, nodePath));
   };
 }
@@ -1265713,7 +1265819,7 @@ async function visitTypeDeclarations({ typeDeclarations, visitor, nodePath }) {
 async function visitTypeDeclaration({ typeName, declaration, visitor, nodePathForType }) {
   var _a6;
   const visitTypeReference = createTypeReferenceVisitor(visitor);
-  await ((_a6 = visitor.typeDeclaration) == null ? void 0 : _a6.call(visitor, { typeName: { isInlined: false, name: typeName }, declaration }, nodePathForType));
+  await ((_a6 = visitor.typeDeclaration) == null ? void 0 : _a6.call(visitor, { typeName: { isInlined: false, name: typeName }, declaration, nodePath: nodePathForType }, nodePathForType));
   const visitExamples = async (examples) => {
     var _a7;
     if (examples == null) {
@@ -1267781,11 +1267887,29 @@ var NoUndefinedTypeReferenceRule = {
       if (typesForFilepath == null) {
         return false;
       }
+      const maybeGeneric = parseGeneric(reference.parsed.typeName);
+      if (maybeGeneric != null) {
+        return maybeGeneric.name ? typesForFilepath.has(maybeGeneric.name) : false;
+      }
       return typesForFilepath.has(reference.parsed.typeName);
     }
+    function checkGenericType(reference, nodePath) {
+      var _a6, _b4, _c4;
+      if (nodePath != null) {
+        const mutableNodePath = [...nodePath];
+        while (mutableNodePath.length > 0) {
+          const nodePathItem = mutableNodePath.pop();
+          const maybeGeneric = nodePathItem ? typeof nodePathItem === "string" ? parseGeneric(nodePathItem) : parseGeneric(nodePathItem.key) : void 0;
+          if (maybeGeneric != null) {
+            return ((_a6 = reference.parsed) == null ? void 0 : _a6.typeName) && ((_c4 = maybeGeneric.arguments) == null ? void 0 : _c4.includes((_b4 = reference.parsed) == null ? void 0 : _b4.typeName));
+          }
+        }
+      }
+      return false;
+    }
     return {
       definitionFile: {
-        typeReference: ({ typeReference, location: location3 }, { relativeFilepath, contents }) => {
+        typeReference: ({ typeReference, location: location3, nodePath }, { relativeFilepath, contents }) => {
           const parsedRawFileType = parseRawFileType(typeReference);
           if (parsedRawFileType != null) {
             if (location3 === TypeReferenceLocation.InlinedRequestProperty) {
@@ -1267848,7 +1267972,7 @@ var NoUndefinedTypeReferenceRule = {
                 severity: "error",
                 message: "The text type can only be used as a response-stream or response."
               });
-            } else if (!doesTypeExist(namedType)) {
+            } else if (!doesTypeExist(namedType) && !checkGenericType(namedType, nodePath)) {
               violations.push({
                 severity: "error",
                 message: `Type ${source_default.bold(((_c4 = namedType.parsed) == null ? void 0 : _c4.typeName) ?? namedType.fullyQualifiedName)} is not defined.`
@@ -1267869,6 +1267993,12 @@ async function getTypesByFilepath(workspace) {
     await visitDefinitionFileYamlAst(file, {
       typeDeclaration: ({ typeName }) => {
         if (!typeName.isInlined) {
+          const maybeGenericDeclaration = parseGeneric(typeName.name);
+          if (maybeGenericDeclaration != null) {
+            if (maybeGenericDeclaration.name) {
+              typesForFile.add(maybeGenericDeclaration.name);
+            }
+          }
           typesForFile.add(typeName.name);
         }
       }
@@ -1267958,6 +1268088,56 @@ var NoUndefinedVariableReferenceRule = {
   }
 };
 
+// ../fern-definition/validator/lib/rules/no-unused-generic/no-unused-generic.js
+var NoUnusedGenericRule = {
+  name: "no-unused-generic",
+  create: async ({ workspace }) => {
+    const instantiations = /* @__PURE__ */ new Set();
+    await visitAllDefinitionFiles(workspace, async (_4, file) => {
+      await visitDefinitionFileYamlAst(file, {
+        typeDeclaration: (type2) => {
+          visitRawTypeDeclaration(type2.declaration, {
+            alias: (alias) => {
+              const maybeGenericDeclaration = parseGeneric(typeof alias === "string" ? alias : alias.type);
+              if (maybeGenericDeclaration != null && maybeGenericDeclaration.name) {
+                const [maybeTypeName, typeName, ..._rest] = maybeGenericDeclaration.name.split(".");
+                const key = typeName ?? maybeTypeName;
+                if (key) {
+                  instantiations.add(key);
+                }
+              }
+            },
+            enum: () => {
+            },
+            object: () => {
+            },
+            discriminatedUnion: () => {
+            },
+            undiscriminatedUnion: () => {
+            }
+          });
+        }
+      });
+    });
+    return {
+      definitionFile: {
+        typeName: (name2) => {
+          const maybeGenericDeclaration = parseGeneric(name2);
+          if (maybeGenericDeclaration == null) {
+            return [];
+          }
+          return maybeGenericDeclaration.name && instantiations.has(maybeGenericDeclaration.name) ? [] : [
+            {
+              severity: "error",
+              message: `Generic "${name2}" is declared but never used.`
+            }
+          ];
+        }
+      }
+    };
+  }
+};
+
 // ../fern-definition/validator/lib/rules/only-object-extensions/only-object-extensions.js
 var OnlyObjectExtensionsRule = {
   name: "only-object-extensions",
@@ -1268576,6 +1268756,181 @@ var ValidFieldNamesRule = {
   }
 };
 
+// ../fern-definition/validator/lib/rules/valid-generic/valid-generic.js
+var ValidGenericRule = {
+  name: "valid-generic",
+  create: async ({ workspace }) => {
+    const genericArgumentCounts = await getGenericArgumentCounts(workspace);
+    const propertyBasedErrors = {
+      object: [],
+      discriminatedUnion: []
+    };
+    return {
+      definitionFile: {
+        typeDeclaration: ({ typeName, declaration, nodePath }) => {
+          const errors2 = [];
+          if (!typeName.isInlined) {
+            const maybeGeneric = parseGeneric(typeName.name);
+            if (maybeGeneric != null) {
+              if (!visitRawTypeDeclaration(declaration, {
+                alias: () => {
+                  return false;
+                },
+                enum: () => {
+                  return false;
+                },
+                object: () => {
+                  return true;
+                },
+                discriminatedUnion: () => {
+                  return false;
+                },
+                undiscriminatedUnion: () => {
+                  return false;
+                }
+              })) {
+                errors2.push({
+                  severity: "error",
+                  message: "Generics are only supported for object declarations"
+                });
+              }
+            }
+          }
+          visitRawTypeDeclaration(declaration, {
+            alias: (aliasValue) => {
+              const alias = typeof aliasValue === "string" ? aliasValue : aliasValue.type;
+              const maybeGeneric = parseGeneric(alias);
+              if (maybeGeneric != null) {
+                const [maybeTypeName, typeName2, ..._rest] = maybeGeneric.name.split(".");
+                const key = typeName2 ?? maybeTypeName;
+                if (key && key in genericArgumentCounts && genericArgumentCounts[key] !== maybeGeneric.arguments.length) {
+                  errors2.push({
+                    severity: "error",
+                    message: `Generic ${key} expects ${genericArgumentCounts[key]} arguments, but received ${maybeGeneric.arguments.length} <${maybeGeneric.arguments.join(",")}>`
+                  });
+                }
+              } else {
+                if (alias in genericArgumentCounts) {
+                  errors2.push({
+                    severity: "error",
+                    message: `Generic ${alias} expects ${genericArgumentCounts[alias]} arguments, but received none`
+                  });
+                }
+              }
+            },
+            enum: (enumValue) => {
+              if (typeof enumValue !== "string") {
+                enumValue.enum.forEach((value) => {
+                  const enumValue2 = typeof value === "string" ? value : value.value;
+                  if (isGeneric(enumValue2)) {
+                    errors2.push({
+                      severity: "error",
+                      message: `Cannot reference generic ${enumValue2} from enum`
+                    });
+                  }
+                });
+              }
+            },
+            object: (objectValue) => {
+              Object.entries((objectValue == null ? void 0 : objectValue.properties) ?? {}).forEach(([key, value]) => {
+                if (isGeneric(typeof value === "string" ? value : value.type)) {
+                  if (nodePath) {
+                    (propertyBasedErrors.object ?? (propertyBasedErrors.object = [])).push({
+                      key,
+                      nodePath
+                    });
+                  } else {
+                    errors2.push({
+                      severity: "error",
+                      message: `Cannot reference generic ${value} from object property ${key}`
+                    });
+                  }
+                }
+              });
+            },
+            discriminatedUnion: (discriminatedUnionValue) => {
+              Object.entries(discriminatedUnionValue.union).forEach(([key, value]) => {
+                const discriminatedUnionValue2 = typeof value === "string" ? value : typeof value.type === "string" ? value.type : void 0;
+                if (discriminatedUnionValue2 && isGeneric(discriminatedUnionValue2)) {
+                  if (nodePath) {
+                    (propertyBasedErrors.discriminatedUnion ?? (propertyBasedErrors.discriminatedUnion = [])).push({
+                      key,
+                      nodePath
+                    });
+                  } else {
+                    errors2.push({
+                      severity: "error",
+                      message: `Cannot reference generic ${value} from union property ${key}`
+                    });
+                  }
+                }
+              });
+            },
+            undiscriminatedUnion: (undiscriminatedUnionValue) => {
+              undiscriminatedUnionValue.union.forEach((value) => {
+                const discriminatedUnionValue = typeof value === "string" ? value : value.type;
+                if (isGeneric(discriminatedUnionValue)) {
+                  errors2.push({
+                    severity: "error",
+                    message: `Cannot reference generic ${discriminatedUnionValue} from union`
+                  });
+                }
+              });
+            }
+          });
+          return errors2;
+        },
+        typeReference: ({ typeReference, nodePath }) => {
+          const errors2 = [];
+          if (nodePath) {
+            for (const propertyBasedTypeDeclaration of Object.keys(propertyBasedErrors)) {
+              for (const { key, nodePath: propertyNodePath } of propertyBasedErrors[propertyBasedTypeDeclaration]) {
+                if (propertyNodePath.length > 0 && nodePath.join(",").startsWith(propertyNodePath.join(",")) && nodePath.includes(key)) {
+                  errors2.push({
+                    severity: "error",
+                    message: `Cannot reference generic ${typeReference} from ${propertyBasedTypeDeclaration.toLowerCase().includes("union") ? "union" : propertyBasedTypeDeclaration}`
+                  });
+                }
+              }
+            }
+          }
+          return errors2;
+        }
+      }
+    };
+  }
+};
+async function getGenericArgumentCounts(workspace) {
+  const genericArgumentCounts = {};
+  await visitAllDefinitionFiles(workspace, async (relativeFilepath, file) => {
+    await visitDefinitionFileYamlAst(file, {
+      typeDeclaration: ({ typeName, declaration }) => {
+        if (!typeName.isInlined) {
+          const maybeGeneric = parseGeneric(typeName.name);
+          if (maybeGeneric != null) {
+            visitRawTypeDeclaration(declaration, {
+              alias: () => {
+              },
+              enum: () => {
+              },
+              object: () => {
+                if (maybeGeneric.name && maybeGeneric.arguments) {
+                  genericArgumentCounts[maybeGeneric.name] = maybeGeneric.arguments.length;
+                }
+              },
+              discriminatedUnion: () => {
+              },
+              undiscriminatedUnion: () => {
+              }
+            });
+          }
+        }
+      }
+    });
+  });
+  return genericArgumentCounts;
+}
+
 // ../fern-definition/validator/lib/rules/valid-navigation/valid-navigation.js
 var import_path32 = __toESM(require("path"), 1);
 var ValidNavigationRule = {
@@ -1270313,7 +1270668,9 @@ function getAllRules() {
     ValidExampleErrorRule,
     ValidTypeReferenceWithDefaultAndValidationRule,
     ValidStreamConditionRule,
-    ValidVersionRule
+    ValidVersionRule,
+    NoUnusedGenericRule,
+    ValidGenericRule
   ];
 }
 function getAllEnabledRules() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fern-api",
-  "version": "0.41.0-rc1",
+  "version": "0.41.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/fern-api/fern.git",