Cas d'étude Theodo

OpenAPI.py

+import { mkdir, writeFile } from "fs/promises";
+
+import openapi from "../openapi.json" assert { type: 'json' };
+import { type } from "os";
+import { types } from "util";
+
+const targetDirectory = "src/lib/spotify/model";
+
+async function generateSpotifyClient() {
+  console.log("\nLaunched generate-spotify-client script");
+  console.log('Generating Spotify client from OpenApi spec file...\n')
+  await mkdir(targetDirectory, { recursive: true }); // Generate target directory
+
+  const schemas = openapi.components.schemas;
+  const typesToGenerate = Object.keys(schemas);
+
+  for (const typeName of typesToGenerate) {
+    const typeSchema = schemas[typeName];
+    generateType(typeName, typeSchema);
+  }
+}
+
+function generateType(typeName, typeSchema) {  
+  console.log(`Generating type ${typeName}...`);
+
+  const generatedCode = getGeneratedCode(typeName, typeSchema);
+
+  writeFile(`${targetDirectory}/${typeName}.ts`, generatedCode);
+}
+
+function getGeneratedCode(typeName, typeSchema) {
+  var libs = []
+  const generatedType = getGeneratedType(typeSchema,libs);
+  var importStr = ""
+  if(libs!=[]){
+    for(const lib of libs){
+      importStr+='import { '+lib+' } from "./'+lib+'";\n'
+    }
+    importStr+='\n'
+  } 
+  return importStr+`export type ${typeName} = ${generatedType};`;
+}
+
+function getGeneratedType(typeSchema, libs, isRequired = true) {
+  if (typeSchema.allOf) {
+    const schemaAllOf = typeSchema.allOf.map(part => {
+      if (part["$ref"]) {
+        const lib = part["$ref"].split("/").at(-1);
+        if (!libs.includes(lib)) {
+          libs.push(lib);
+        }
+        return lib;
+      }
+      return getGeneratedType(part, libs);
+    });
+    return schemaAllOf.join(" & ");
+  }
+
+  const schemaType = typeSchema.type;
+
+  switch (schemaType) {
+    case "number":
+      return `number`;
+    case "integer":
+      return `number`;
+    case "string":
+      if (typeSchema.enum) {
+        const enumValues = typeSchema.enum.map(value => `"${value}"`).join(" | ");
+        return `${enumValues}`;
+      }
+      return `string`;
+    case "boolean":
+      return `boolean`;
+    case "array":
+      if (typeSchema.items) {
+        if (typeSchema.items["oneOf"]) {
+          const oneOfTypes = typeSchema.items["oneOf"]
+            .map(option => {
+              if (option["$ref"]) {
+                const lib = option["$ref"].split("/").at(-1);
+                if (!libs.includes(lib)) {
+                  libs.push(lib);
+                }
+                return lib;
+              }
+              return getGeneratedType(option, libs);
+            })
+            .join(" | ");
+          return `(${oneOfTypes})[]`;
+        } else if (typeSchema.items["$ref"]) {
+          const lib = typeSchema.items["$ref"].split("/").at(-1);
+          if (!libs.includes(lib)) {
+            libs.push(lib);
+          }
+          return `${lib}[]`;
+        } else {
+          const itemsType = getGeneratedType(typeSchema.items, libs);
+          return `${itemsType}[]`;
+        }
+      }
+      return `any[]`;
+    case "object":
+      const requiredList = typeSchema.required || [];
+      let res = "{";
+
+      if (typeSchema.properties) {
+        for (const key of Object.keys(typeSchema.properties)) {
+          const isPropRequired = requiredList.includes(key);
+          const propertySchema = typeSchema.properties[key];
+
+          if (propertySchema["oneOf"]) {
+            const oneOfTypes = propertySchema["oneOf"]
+              .map(option => {
+                if (option["$ref"]) {
+                  const lib = option["$ref"].split("/").at(-1);
+                  if (!libs.includes(lib)) {
+                    libs.push(lib);
+                  }
+                  return lib;
+                }
+                return getGeneratedType(option, libs);
+              })
+              .join(" | ");
+
+            res += isPropRequired
+              ? `\n  ${key}: (${oneOfTypes});`
+              : `\n  ${key}?: (${oneOfTypes});`;
+          } else if (propertySchema["$ref"]) {
+            const lib = propertySchema["$ref"].split("/").at(-1);
+            if (!libs.includes(lib)) {
+              libs.push(lib);
+            }
+            res += isPropRequired
+              ? `\n  ${key}: ${lib};`
+              : `\n  ${key}?: ${lib};`;
+          } else if (propertySchema.allOf) {
+            const combinedType = getGeneratedType(propertySchema, libs);
+            res += isPropRequired
+              ? `\n  ${key}: ${combinedType};`
+              : `\n  ${key}?: ${combinedType};`;
+          } else {
+            const propertyType = getGeneratedType(propertySchema, libs, isPropRequired);
+            res += isPropRequired
+              ? `\n  ${key}: ${propertyType};`
+              : `\n  ${key}?: ${propertyType};`;
+          }
+        }
+      }
+      res += "\n}";
+      return res;
+
+    default:
+      return ``;
+  }
+}
+
+generateSpotifyClient();
\ No newline at end of file