rastack 0.0.16

package/src/schema-entities.ts

@@ -0,0 +1,401 @@
+import { mkdirSync, writeFileSync } from "fs";
+import { join } from "path";
+import {
+  OperationObject,
+  ParameterObject,
+  PathsObject,
+  RequestBodyObject,
+} from "@ts-stack/openapi-spec";
+import { extractResponseBodySchema } from "./schema/extract-response";
+import { fetchSchema } from "./schema/fetch-schema";
+import { removeNonModelPaths } from "./schema/remove-non-model-paths";
+import { camelToPastel } from "./schema/camel-to-pastel";
+import { generateGetAPIMethod } from "./entity-generation/get-method";
+import { generateUpdateAPIMethod } from "./entity-generation/update-method";
+import {
+  generateFolderImports,
+  generateImportStatements,
+  generateIndexImports,
+  generateKeyImports,
+} from "./entity-generation/imports";
+import { generateUpdateFormMethod } from "./entity-generation/form";
+import { generateDeleteAPIMethod } from "./entity-generation/delete-method";
+import {
+  EntitySyncMeta,
+  generateConfirmedMethod,
+  generateEntityDescriptor,
+  generateSyncDeleteMethod,
+  generateSyncListMethod,
+  generateSyncRecordMethod,
+  generateSyncUpdateMethod,
+} from "./entity-generation/sync-method";
+import { toCamelCase } from "./schema/to-camel-case";
+
+function pathSegments(pathKey: string): string[] {
+  return pathKey.replace(/\/$/, "").split("/");
+}
+
+/**
+ * Pre-pass over the OpenAPI paths: collects, per entity, the sync mode
+ * (from rastack's `x-rastack-sync` vendor extension), confirmed operations,
+ * the list/detail URLs, the row schema, and the list/detail operation ids
+ * (used to wire cache invalidation for non-sync entities).
+ */
+export function collectEntityMeta(paths: PathsObject): {
+  [indexKey: string]: EntitySyncMeta;
+} {
+  const meta: { [indexKey: string]: EntitySyncMeta } = {};
+
+  Object.keys(paths).forEach((pathKey) => {
+    const appName = pathKey.split("/")[2];
+    const modelName = pathKey.split("/")[4];
+    const indexKey = `${appName}|${modelName}`;
+    if (!meta[indexKey]) {
+      meta[indexKey] = { sync: false, confirmedOperationIds: new Set() };
+    }
+    const entityMeta = meta[indexKey];
+
+    const segments = pathSegments(pathKey);
+    const isListPath = segments.length === 5;
+    const isDetailPath = segments.length === 6 && segments[5].startsWith("{");
+    if (isListPath) {
+      entityMeta.listUrl = pathKey;
+    }
+    if (isDetailPath) {
+      entityMeta.detailUrl = pathKey;
+      entityMeta.detailParam = segments[5].slice(1, -1);
+    }
+
+    Object.keys(paths[pathKey]).forEach((method) => {
+      // @ts-ignore
+      const operation = paths[pathKey][method] as OperationObject;
+      const syncExtension = (operation as any)["x-rastack-sync"];
+      if (syncExtension === "local" || syncExtension === "confirmed") {
+        entityMeta.sync = true;
+      }
+      if ((operation as any)["x-rastack-sync-load"] === "lazy") {
+        entityMeta.lazy = true;
+      }
+      if ((operation as any)["x-rastack-sync-client-ids"] === true) {
+        entityMeta.clientIds = true;
+      }
+      if (syncExtension === "confirmed" && operation.operationId) {
+        entityMeta.confirmedOperationIds.add(operation.operationId as string);
+      }
+
+      const [responseBodySchema, isList] =
+        extractResponseBodySchema(operation);
+      const operationId = (operation.operationId as string) || "";
+      const isPostList =
+        method === "post" &&
+        (operationId.includes("List") || operationId.includes("list"));
+
+      if (method === "get" || isPostList) {
+        if (isList || isPostList) {
+          if (isListPath && !entityMeta.listOperationId) {
+            entityMeta.listOperationId = operationId;
+          }
+        } else if (isDetailPath && !entityMeta.detailOperationId) {
+          entityMeta.detailOperationId = operationId;
+        }
+        if (responseBodySchema && !entityMeta.rowSchema) {
+          entityMeta.rowSchema = `I${responseBodySchema}`;
+        }
+      }
+    });
+  });
+
+  return meta;
+}
+
+export async function generateFolders(
+  entitiesPath: string,
+  paths: PathsObject,
+): Promise<void> {
+  Object.keys(paths).forEach((key) => {
+    const appName = key.split("/")[2];
+    const modelName = key.split("/")[4];
+    const appFolder = join(entitiesPath, appName);
+    const modelFolder = join(appFolder, modelName);
+
+    mkdirSync(appFolder, { recursive: true });
+    mkdirSync(modelFolder, { recursive: true });
+  });
+}
+
+export async function generateFiles(
+  entitiesPath: string,
+  paths: PathsObject,
+): Promise<void> {
+  const uniqueOperationNames: string[] = [];
+  const modelFileImports: { [key: string]: Set<string> } = {};
+  const modelFileData: { [key: string]: string } = {};
+  const keysFileData: { [key: string]: string[] } = {};
+  const modelImportsFileData: { [key: string]: string[] } = {};
+  const formMutationOperations: { [key: string]: any } = {};
+  const entityMeta = collectEntityMeta(paths);
+
+  Object.keys(paths).forEach((pathKey) => {
+    const appName = pathKey.split("/")[2];
+    const modelName = pathKey.split("/")[4];
+
+    const indexKey = `${appName}|${modelName}`;
+    if (!formMutationOperations[indexKey]) {
+      formMutationOperations[indexKey] = {
+        post: {
+          operationId: undefined,
+          schema: undefined,
+        },
+        put: {
+          operationId: undefined,
+          schema: undefined,
+        },
+        patch: {
+          operationId: undefined,
+          schema: undefined,
+        },
+      };
+    }
+    if (!modelImportsFileData[appName]) {
+      modelImportsFileData[appName] = [modelName];
+    } else {
+      if (!modelImportsFileData[appName].includes(modelName)) {
+        modelImportsFileData[appName].push(modelName);
+      }
+    }
+
+    Object.keys(paths[pathKey]).forEach((method) => {
+      // @ts-ignore
+      const methodInformation = paths[pathKey][method] as OperationObject;
+
+      const methodParameters =
+        methodInformation.parameters as ParameterObject[];
+      const pathParameters = methodParameters
+        ? methodParameters
+            .filter((item) => item.required)
+            .filter((item) => item.in === "path")
+            .map((item) => item.name)
+        : [];
+
+      const requestBody = methodInformation.requestBody as RequestBodyObject;
+      // @ts-ignore
+      const requestBodySchema = requestBody?.content?.[
+        "application/json"
+      ]?.schema["$ref"]?.replace("#/components/schemas/", "");
+
+      let [responseBodySchema, isList] =
+        extractResponseBodySchema(methodInformation);
+
+      const requiredParameters = methodParameters
+        ? methodParameters
+            .filter((item) => item.required)
+            .map((item) => item.name)
+        : [];
+
+      const operationId = methodInformation.operationId as string;
+
+      if (!uniqueOperationNames.includes(operationId)) {
+        uniqueOperationNames.push(operationId);
+
+        let apiMethods = "";
+        let importStatements = new Set<string>();
+
+        const isPostListEndpoint =
+          method === "post" &&
+          (operationId.includes("List") || operationId.includes("list"));
+        const isListEndpoint = isList || isPostListEndpoint;
+
+        const meta = entityMeta[indexKey];
+        const isSyncEntity = meta?.sync === true;
+        const isConfirmedOperation =
+          (methodInformation as any)["x-rastack-sync"] === "confirmed" &&
+          method !== "get";
+        const modelCamel = toCamelCase(modelName);
+        const listKeyRef = meta?.listOperationId
+          ? `${modelCamel}QueriesKeys.${meta.listOperationId}`
+          : undefined;
+        const itemKeyRef = meta?.detailOperationId
+          ? `${modelCamel}QueriesKeys.${meta.detailOperationId}`
+          : undefined;
+
+        if (isConfirmedOperation) {
+          [apiMethods, importStatements] = generateConfirmedMethod(
+            pathKey,
+            method,
+            operationId,
+            requestBodySchema ? `I${requestBodySchema}` : undefined,
+            responseBodySchema ? `I${responseBodySchema}` : undefined,
+          );
+
+          formMutationOperations[indexKey] = {
+            ...formMutationOperations[indexKey],
+            [pathKey]: {
+              [method]: {
+                operationId: camelToPastel(operationId),
+                schema: requestBodySchema ? `I${requestBodySchema}` : "",
+              },
+            },
+          };
+        } else if (method === "get" || isPostListEndpoint) {
+          if (isSyncEntity && isListEndpoint) {
+            [apiMethods, importStatements] = generateSyncListMethod(
+              modelName,
+              operationId,
+              meta.rowSchema,
+            );
+          } else if (isSyncEntity && pathKey.includes("{")) {
+            const urlParams =
+              pathKey.match(/{([^}]+)}/g)?.map((param) => param.slice(1, -1)) ||
+              [];
+            [apiMethods, importStatements] = generateSyncRecordMethod(
+              modelName,
+              operationId,
+              meta.rowSchema,
+              pathParameters.length > 0 ? pathParameters : urlParams,
+            );
+          } else {
+            [apiMethods, importStatements] = generateGetAPIMethod(
+              pathKey,
+              modelName,
+              operationId,
+              responseBodySchema ? `I${responseBodySchema}` : undefined,
+              isListEndpoint,
+              pathParameters,
+              requiredParameters,
+              method,
+              requestBodySchema !== undefined ? requestBodySchema : "",
+            );
+          }
+        } else if (
+          method === "post" ||
+          method === "put" ||
+          method === "patch"
+        ) {
+          if (isSyncEntity) {
+            [apiMethods, importStatements] = generateSyncUpdateMethod(
+              pathKey,
+              method,
+              modelName,
+              operationId,
+              requestBodySchema ? `I${requestBodySchema}` : undefined,
+              responseBodySchema ? `I${responseBodySchema}` : undefined,
+              pathParameters,
+            );
+          } else {
+            [apiMethods, importStatements] = generateUpdateAPIMethod(
+              pathKey,
+              method,
+              operationId,
+              requestBodySchema ? `I${requestBodySchema}` : undefined,
+              responseBodySchema ? `I${responseBodySchema}` : undefined,
+              listKeyRef,
+              itemKeyRef,
+            );
+          }
+
+          formMutationOperations[indexKey] = {
+            ...formMutationOperations[indexKey],
+            [pathKey]: {
+              [method]: {
+                operationId: camelToPastel(operationId),
+                schema: requestBodySchema ? `I${requestBodySchema}` : "",
+              },
+            },
+          };
+        } else if (method === "delete") {
+          if (isSyncEntity) {
+            [apiMethods, importStatements] = generateSyncDeleteMethod(
+              pathKey,
+              modelName,
+              operationId,
+            );
+          } else {
+            [apiMethods, importStatements] = generateDeleteAPIMethod(
+              pathKey,
+              operationId,
+              listKeyRef,
+            );
+          }
+        }
+
+        modelFileData[indexKey] = (modelFileData[indexKey] || "") + apiMethods;
+        modelFileImports[indexKey] = new Set([
+          ...(modelFileImports[indexKey] || []),
+          ...importStatements,
+        ]);
+        keysFileData[indexKey] = [
+          ...(keysFileData[indexKey] || []),
+          operationId,
+        ];
+      }
+    });
+  });
+
+  Object.keys(modelFileData).forEach((key) => {
+    const [appName, modelName] = key.split("|");
+    const modelFolder = join(entitiesPath, appName, modelName);
+    const apiFile = join(modelFolder, "api.ts");
+    const indexFile = join(modelFolder, "index.ts");
+    const keyImports = generateKeyImports(modelName, keysFileData[key]);
+
+    const [updateFormMethod, importStatements] = generateUpdateFormMethod(
+      appName,
+      modelName,
+      formMutationOperations[key],
+    );
+    const indexKey = `${appName}|${modelName}`;
+    modelFileImports[indexKey] = new Set([
+      ...(modelFileImports[indexKey] || []),
+      ...importStatements,
+    ]);
+
+    let entityDescriptor = "";
+    if (entityMeta[key]?.sync) {
+      const [descriptorCode, descriptorImports] = generateEntityDescriptor(
+        appName,
+        modelName,
+        entityMeta[key],
+      );
+      entityDescriptor = descriptorCode;
+      modelFileImports[indexKey] = new Set([
+        ...(modelFileImports[indexKey] || []),
+        ...descriptorImports,
+      ]);
+    }
+
+    const importData = generateImportStatements(
+      modelFileImports[key],
+      modelName,
+    );
+
+    const apiFileText = `${importData}\n${keyImports}\n${entityDescriptor}${modelFileData[key]}\n${updateFormMethod}`;
+    const indexImports = generateIndexImports(modelName, keysFileData[key]);
+
+    writeFileSync(apiFile, apiFileText, { flag: "w" });
+    writeFileSync(indexFile, indexImports, { flag: "w" });
+  });
+
+  // create an index file with all the file names per model
+  Object.keys(modelImportsFileData).forEach((key) => {
+    const modelFolder = join(entitiesPath, key);
+    const indexFile = join(modelFolder, "index.ts");
+
+    const indexImports = generateFolderImports(modelImportsFileData[key]);
+    writeFileSync(indexFile, indexImports, { flag: "w" });
+  });
+}
+
+export async function main(url: string, entitiesPath: string): Promise<void> {
+  console.log("Generating Entities");
+  const data = await fetchSchema(url);
+  const filteredPaths = removeNonModelPaths(data.paths);
+  await generateFolders(entitiesPath, filteredPaths);
+  await generateFiles(entitiesPath, filteredPaths);
+}
+
+if (require.main === module) {
+  const args: string[] = process.argv.slice(2);
+  const url = args[0];
+  const entitiesPath = args[1];
+  main(url, entitiesPath);
+}

package/src/schema-fetch.ts

@@ -0,0 +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();

package/src/schema-full.ts

@@ -0,0 +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();

package/src/schema-index.ts

@@ -0,0 +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();

package/src/schema-params.ts

@@ -0,0 +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();