rastack 0.0.16 → 0.0.19

package/src/schema-fetch.ts

@@ -1,82 +1,82 @@
-import { readdirSync, readFileSync, writeFileSync } from "fs";
-import { join } from "path";
-import axios, { AxiosResponse } from "axios";
-
-interface OpenAPISchema {
-  components: { schemas: Record<string, any> };
-}
-
-async function fetchSchema(
-  url: string,
-  schemaPath: string,
-): Promise<OpenAPISchema> {
-  const response: AxiosResponse<OpenAPISchema> = await axios.get(url);
-  writeFileSync(schemaPath, JSON.stringify(response.data, null, 2));
-  return response.data;
-}
-
-async function generateFiles(
-  basePath: string,
-  components: { schemas: Record<string, any> },
-): Promise<void> {
-  const schemas = components.schemas;
-  Object.keys(schemas).forEach((key) => {
-    const schema = schemas[key];
-    let schemaKey = key;
-    if (key.endsWith("Enum")) {
-      schemaKey = key.replace("Enum", "");
-      schemaKey = `E${schemaKey}`;
-    } else {
-      schemaKey = `I${schemaKey}`;
-    }
-    const schemaFolderPath = join(basePath, "api-schema");
-    const fileName = `${schemaFolderPath}/${schemaKey}.json`;
-    writeFileSync(fileName, JSON.stringify(schema, null, 2));
-  });
-}
-
-async function replaceReferences(basePath: string): Promise<void> {
-  const schemaFolderPath = join(basePath, "api-schema");
-  const schemaFiles = readdirSync(schemaFolderPath);
-
-  schemaFiles.forEach((file) => {
-    const filePath = join(schemaFolderPath, file);
-    const fileContent = JSON.parse(readFileSync(filePath, "utf8"));
-    let convertedSchema = JSON.stringify(fileContent);
-
-    const searchPattern = /"#\/components\/schemas\/([A-Za-z0-9_-]+)"/g;
-
-    convertedSchema = convertedSchema.replace(
-      searchPattern,
-      (_, matchedSchemaName) => {
-        let updatedSchemaName = matchedSchemaName;
-
-        if (updatedSchemaName.endsWith("Enum")) {
-          updatedSchemaName = updatedSchemaName.replace("Enum", "");
-          updatedSchemaName = `E${updatedSchemaName}`;
-        } else {
-          updatedSchemaName = `I${updatedSchemaName}`;
-        }
-
-        return `"${updatedSchemaName}.json"`;
-      },
-    );
-
-    const writeSchema = JSON.parse(convertedSchema);
-    writeFileSync(filePath, JSON.stringify(writeSchema, null, 2));
-  });
-}
-
-async function main() {
-  console.log("Fetching Schema");
-  const args: string[] = process.argv.slice(2);
-  const url = args[0];
-  const basePath = args[1];
-  const schemaPath = join(basePath, "schema.json");
-  const { components } = await fetchSchema(url, schemaPath);
-
-  await generateFiles(basePath, components);
-  await replaceReferences(basePath);
-}
-
-main();
+import { readdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import axios, { AxiosResponse } from "axios";
+
+interface OpenAPISchema {
+  components: { schemas: Record<string, any> };
+}
+
+async function fetchSchema(
+  url: string,
+  schemaPath: string,
+): Promise<OpenAPISchema> {
+  const response: AxiosResponse<OpenAPISchema> = await axios.get(url);
+  writeFileSync(schemaPath, JSON.stringify(response.data, null, 2));
+  return response.data;
+}
+
+async function generateFiles(
+  basePath: string,
+  components: { schemas: Record<string, any> },
+): Promise<void> {
+  const schemas = components.schemas;
+  Object.keys(schemas).forEach((key) => {
+    const schema = schemas[key];
+    let schemaKey = key;
+    if (key.endsWith("Enum")) {
+      schemaKey = key.replace("Enum", "");
+      schemaKey = `E${schemaKey}`;
+    } else {
+      schemaKey = `I${schemaKey}`;
+    }
+    const schemaFolderPath = join(basePath, "api-schema");
+    const fileName = `${schemaFolderPath}/${schemaKey}.json`;
+    writeFileSync(fileName, JSON.stringify(schema, null, 2));
+  });
+}
+
+async function replaceReferences(basePath: string): Promise<void> {
+  const schemaFolderPath = join(basePath, "api-schema");
+  const schemaFiles = readdirSync(schemaFolderPath);
+
+  schemaFiles.forEach((file) => {
+    const filePath = join(schemaFolderPath, file);
+    const fileContent = JSON.parse(readFileSync(filePath, "utf8"));
+    let convertedSchema = JSON.stringify(fileContent);
+
+    const searchPattern = /"#\/components\/schemas\/([A-Za-z0-9_-]+)"/g;
+
+    convertedSchema = convertedSchema.replace(
+      searchPattern,
+      (_, matchedSchemaName) => {
+        let updatedSchemaName = matchedSchemaName;
+
+        if (updatedSchemaName.endsWith("Enum")) {
+          updatedSchemaName = updatedSchemaName.replace("Enum", "");
+          updatedSchemaName = `E${updatedSchemaName}`;
+        } else {
+          updatedSchemaName = `I${updatedSchemaName}`;
+        }
+
+        return `"${updatedSchemaName}.json"`;
+      },
+    );
+
+    const writeSchema = JSON.parse(convertedSchema);
+    writeFileSync(filePath, JSON.stringify(writeSchema, null, 2));
+  });
+}
+
+async function main() {
+  console.log("Fetching Schema");
+  const args: string[] = process.argv.slice(2);
+  const url = args[0];
+  const basePath = args[1];
+  const schemaPath = join(basePath, "schema.json");
+  const { components } = await fetchSchema(url, schemaPath);
+
+  await generateFiles(basePath, components);
+  await replaceReferences(basePath);
+}
+
+main();

package/src/schema-full.ts

@@ -1,38 +1,38 @@
-import { readdirSync, readFileSync, writeFileSync } from "fs";
-import { join } from "path";
-
-const $RefParser = require("@apidevtools/json-schema-ref-parser");
-
-async function generateDereferencedSchema(schemaPath: string): Promise<string> {
-  try {
-    const schemaContent = readFileSync(schemaPath, "utf8");
-    const schemaObject = JSON.parse(schemaContent);
-
-    const dereferencedSchema = await $RefParser.dereference(schemaObject);
-    return JSON.stringify(dereferencedSchema, null, 2);
-  } catch (error) {
-    return "";
-  }
-}
-
-async function main() {
-  console.log("Resolving Schemas");
-  const args: string[] = process.argv.slice(2);
-  const basePath = args[0];
-  const schemaFolderPath = join(basePath, "api-schema");
-  const outputFolder = join(basePath, "form-schema");
-
-  const schemaFiles = readdirSync(schemaFolderPath);
-
-  let compilePromises = schemaFiles.map(async (schemaFile) => {
-    const schemaFilePath = join(schemaFolderPath, schemaFile);
-
-    const generatedCode = await generateDereferencedSchema(schemaFilePath);
-
-    const outputFilePath = join(outputFolder, schemaFile);
-    writeFileSync(outputFilePath, generatedCode);
-  });
-  let results = await Promise.all(compilePromises);
-}
-
-main();
+import { readdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+
+const $RefParser = require("@apidevtools/json-schema-ref-parser");
+
+async function generateDereferencedSchema(schemaPath: string): Promise<string> {
+  try {
+    const schemaContent = readFileSync(schemaPath, "utf8");
+    const schemaObject = JSON.parse(schemaContent);
+
+    const dereferencedSchema = await $RefParser.dereference(schemaObject);
+    return JSON.stringify(dereferencedSchema, null, 2);
+  } catch (error) {
+    return "";
+  }
+}
+
+async function main() {
+  console.log("Resolving Schemas");
+  const args: string[] = process.argv.slice(2);
+  const basePath = args[0];
+  const schemaFolderPath = join(basePath, "api-schema");
+  const outputFolder = join(basePath, "form-schema");
+
+  const schemaFiles = readdirSync(schemaFolderPath);
+
+  let compilePromises = schemaFiles.map(async (schemaFile) => {
+    const schemaFilePath = join(schemaFolderPath, schemaFile);
+
+    const generatedCode = await generateDereferencedSchema(schemaFilePath);
+
+    const outputFilePath = join(outputFolder, schemaFile);
+    writeFileSync(outputFilePath, generatedCode);
+  });
+  let results = await Promise.all(compilePromises);
+}
+
+main();

package/src/schema-index.ts

@@ -1,29 +1,29 @@
-import { join } from "path";
-import { readdirSync, writeFileSync } from "fs";
-
-async function main() {
-  console.log("Generating Schema Index");
-  const args: string[] = process.argv.slice(2);
-  const basePath = args[0];
-  const schemaFolderPath = join(basePath, "form-schema");
-
-  let indexFileData =
-    'export * from "./interface";\nexport * from "./params";\n';
-
-  const schemaFiles = readdirSync(schemaFolderPath);
-
-  let compilePromises = schemaFiles.map((schemaFile) => {
-    const schemaFileName = schemaFile.replace(".json", "");
-    const formSchemaExport = `export { default as Deref${schemaFileName} } from "./form-schema/${schemaFile}";`;
-    const schemaExport = `export { default as Schema${schemaFileName} } from "./api-schema/${schemaFile}";`;
-    return `${formSchemaExport}\n${schemaExport}`;
-  });
-
-  let results = await Promise.all(compilePromises);
-  indexFileData = indexFileData + results.join("\n");
-
-  const outputFile = join(basePath, "index.ts");
-  writeFileSync(outputFile, indexFileData);
-}
-
-main();
+import { join } from "path";
+import { readdirSync, writeFileSync } from "fs";
+
+async function main() {
+  console.log("Generating Schema Index");
+  const args: string[] = process.argv.slice(2);
+  const basePath = args[0];
+  const schemaFolderPath = join(basePath, "form-schema");
+
+  let indexFileData =
+    'export * from "./interface";\nexport * from "./params";\n';
+
+  const schemaFiles = readdirSync(schemaFolderPath);
+
+  let compilePromises = schemaFiles.map((schemaFile) => {
+    const schemaFileName = schemaFile.replace(".json", "");
+    const formSchemaExport = `export { default as Deref${schemaFileName} } from "./form-schema/${schemaFile}";`;
+    const schemaExport = `export { default as Schema${schemaFileName} } from "./api-schema/${schemaFile}";`;
+    return `${formSchemaExport}\n${schemaExport}`;
+  });
+
+  let results = await Promise.all(compilePromises);
+  indexFileData = indexFileData + results.join("\n");
+
+  const outputFile = join(basePath, "index.ts");
+  writeFileSync(outputFile, indexFileData);
+}
+
+main();

package/src/schema-params.ts

@@ -1,116 +1,116 @@
-import { writeFileSync } from "fs";
-import {
-  ComponentsObject,
-  ParameterObject,
-  PathsObject,
-} from "@ts-stack/openapi-spec";
-import { OperationObject } from "@ts-stack/openapi-spec/src/origin/operation-object";
-import { join } from "path";
-import { fetchSchema } from "./schema/fetch-schema";
-
-interface OpenAPISchema {
-  paths: PathsObject;
-  components: ComponentsObject;
-}
-
-interface PathParamItem {
-  name: string;
-  required: boolean;
-  schema: object | undefined;
-}
-
-interface PathParam {
-  operationName: string;
-  paramsArray: PathParamItem[];
-}
-
-function generateParams(paths: PathsObject): PathParam[] {
-  const pathParam: PathParam[] = [];
-  Object.keys(paths).map((path) => {
-    const pathItem = paths[path];
-    console.log(path);
-    Object.keys(pathItem).forEach((method) => {
-      // @ts-ignore
-      const pathOperation: OperationObject = pathItem[method];
-      const pathParamData: PathParamItem[] = [];
-      if (pathOperation.parameters) {
-        pathOperation.parameters.forEach((param) => {
-          // @ts-ignore
-          const paramObject: ParameterObject = param;
-          pathParamData.push({
-            name: paramObject.name,
-            required: paramObject.required || false,
-            schema: paramObject.schema,
-          });
-        });
-      }
-      if (pathOperation.operationId) {
-        // Operation id to snake case to camelcase and remove the text v1
-        const operationId = pathOperation.operationId;
-        const camelCaseOperationId = operationId
-          .replace(/_v1/g, "")
-          .replace(/_([a-z])/g, function (g) {
-            return g[1].toUpperCase();
-          });
-        const capitalizedOperationId =
-          camelCaseOperationId.charAt(0).toUpperCase() +
-          camelCaseOperationId.slice(1);
-
-        pathParam.push({
-          operationName: capitalizedOperationId,
-          paramsArray: pathParamData,
-        });
-      }
-    });
-  });
-  return pathParam;
-}
-
-function generateInterfacesFiles(pathParams: PathParam[], schemaPath: string) {
-  const interfaceFileValues = pathParams.map((pathParam) => {
-    const interfaceName = `I${pathParam.operationName}Params`;
-    const interfaceValues = pathParam.paramsArray.map((param) => {
-      let paramSchemaType = "string";
-      if (param.schema) {
-        // @ts-ignore
-        if (param.schema.type === "array") {
-          // @ts-ignore
-          if (param.schema.items.enum) {
-            // @ts-ignore
-            paramSchemaType = param.schema.items.enum
-              .map((value: string) => `"${value}"`)
-              .join(" | ");
-            paramSchemaType = `(${paramSchemaType})[]`;
-          }
-        } else {
-          // @ts-ignore
-          if (param.schema.type === "integer") {
-            paramSchemaType = "number";
-          }
-        }
-      }
-
-      return `${param.name}${param.required ? "" : "?"}: ${paramSchemaType};`;
-    });
-    return `export interface ${interfaceName} {
-      ${interfaceValues.join("\n")}
-    }`;
-  });
-  const interfaceFileValuesString = interfaceFileValues.join("\n");
-  const interfaceFile = join(schemaPath, `params.ts`);
-  writeFileSync(interfaceFile, interfaceFileValuesString, { flag: "w" });
-}
-
-async function main() {
-  console.log("Generating Schema Parameter Definitions");
-  const args: string[] = process.argv.slice(2);
-  const url = args[0];
-  const schemaPath = args[1];
-  const data = await fetchSchema(url);
-  const paths = data.paths;
-  const pathParams = generateParams(paths);
-
-  generateInterfacesFiles(pathParams, schemaPath);
-}
-
-main();
+import { writeFileSync } from "fs";
+import {
+  ComponentsObject,
+  ParameterObject,
+  PathsObject,
+} from "@ts-stack/openapi-spec";
+import { OperationObject } from "@ts-stack/openapi-spec/src/origin/operation-object";
+import { join } from "path";
+import { fetchSchema } from "./schema/fetch-schema";
+
+interface OpenAPISchema {
+  paths: PathsObject;
+  components: ComponentsObject;
+}
+
+interface PathParamItem {
+  name: string;
+  required: boolean;
+  schema: object | undefined;
+}
+
+interface PathParam {
+  operationName: string;
+  paramsArray: PathParamItem[];
+}
+
+function generateParams(paths: PathsObject): PathParam[] {
+  const pathParam: PathParam[] = [];
+  Object.keys(paths).map((path) => {
+    const pathItem = paths[path];
+    console.log(path);
+    Object.keys(pathItem).forEach((method) => {
+      // @ts-ignore
+      const pathOperation: OperationObject = pathItem[method];
+      const pathParamData: PathParamItem[] = [];
+      if (pathOperation.parameters) {
+        pathOperation.parameters.forEach((param) => {
+          // @ts-ignore
+          const paramObject: ParameterObject = param;
+          pathParamData.push({
+            name: paramObject.name,
+            required: paramObject.required || false,
+            schema: paramObject.schema,
+          });
+        });
+      }
+      if (pathOperation.operationId) {
+        // Operation id to snake case to camelcase and remove the text v1
+        const operationId = pathOperation.operationId;
+        const camelCaseOperationId = operationId
+          .replace(/_v1/g, "")
+          .replace(/_([a-z])/g, function (g) {
+            return g[1].toUpperCase();
+          });
+        const capitalizedOperationId =
+          camelCaseOperationId.charAt(0).toUpperCase() +
+          camelCaseOperationId.slice(1);
+
+        pathParam.push({
+          operationName: capitalizedOperationId,
+          paramsArray: pathParamData,
+        });
+      }
+    });
+  });
+  return pathParam;
+}
+
+function generateInterfacesFiles(pathParams: PathParam[], schemaPath: string) {
+  const interfaceFileValues = pathParams.map((pathParam) => {
+    const interfaceName = `I${pathParam.operationName}Params`;
+    const interfaceValues = pathParam.paramsArray.map((param) => {
+      let paramSchemaType = "string";
+      if (param.schema) {
+        // @ts-ignore
+        if (param.schema.type === "array") {
+          // @ts-ignore
+          if (param.schema.items.enum) {
+            // @ts-ignore
+            paramSchemaType = param.schema.items.enum
+              .map((value: string) => `"${value}"`)
+              .join(" | ");
+            paramSchemaType = `(${paramSchemaType})[]`;
+          }
+        } else {
+          // @ts-ignore
+          if (param.schema.type === "integer") {
+            paramSchemaType = "number";
+          }
+        }
+      }
+
+      return `${param.name}${param.required ? "" : "?"}: ${paramSchemaType};`;
+    });
+    return `export interface ${interfaceName} {
+      ${interfaceValues.join("\n")}
+    }`;
+  });
+  const interfaceFileValuesString = interfaceFileValues.join("\n");
+  const interfaceFile = join(schemaPath, `params.ts`);
+  writeFileSync(interfaceFile, interfaceFileValuesString, { flag: "w" });
+}
+
+async function main() {
+  console.log("Generating Schema Parameter Definitions");
+  const args: string[] = process.argv.slice(2);
+  const url = args[0];
+  const schemaPath = args[1];
+  const data = await fetchSchema(url);
+  const paths = data.paths;
+  const pathParams = generateParams(paths);
+
+  generateInterfacesFiles(pathParams, schemaPath);
+}
+
+main();