rastack 0.0.16

package/src/entity-generation/form.ts

@@ -0,0 +1,169 @@
+import { toPascalCase } from "../schema/to-pastel-case";
+
+type MutationOperation = {
+  operationId: string;
+  schema: string;
+};
+
+type MutationOperations = {
+  [path: string]: {
+    put?: MutationOperation;
+    post?: MutationOperation;
+    patch?: MutationOperation;
+  };
+};
+
+type GroupedMutations = {
+  [functionName: string]: {
+    groupDetailClean: string;
+    mutations: string[];
+  };
+};
+
+export function generateUpdateFormMethod(
+  appName: string,
+  modelName: string,
+  mutationOperations: MutationOperations,
+) {
+  const modelDetail = toPascalCase(modelName);
+  const importStatements = new Set<string>();
+  const groupedMutations: GroupedMutations = {};
+
+  Object.entries(mutationOperations).forEach(([path, operations]) => {
+    const pathParts = path.split("/");
+    const groupDetail = toPascalCase(pathParts.slice(3).join("_"));
+    const groupDetailClean = cleanGroupDetail(groupDetail);
+    const functionName = `useUpdate${modelDetail}${groupDetailClean}Form`;
+
+    const mutations = generateMutations(operations);
+    if (mutations) {
+      if (!groupedMutations[functionName]) {
+        groupedMutations[functionName] = {
+          groupDetailClean,
+          mutations: [],
+        };
+      }
+      groupedMutations[functionName].mutations.push(mutations);
+
+      Object.values(operations).forEach((operation) => {
+        if (operation && operation.schema) {
+          importStatements.add(`Deref${operation.schema}`);
+        }
+      });
+    }
+  });
+
+  const formCodeGen = Object.entries(groupedMutations)
+    .map(([functionName, { groupDetailClean, mutations }]) =>
+      generateFormMethod(groupDetailClean, mutations.join(",\n    ")),
+    )
+    .join("\n\n");
+
+  return [formCodeGen, importStatements];
+}
+
+function cleanGroupDetail(groupDetail: string): string {
+  return groupDetail
+    .replace("V1", "")
+    .split("_")
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+    .join("")
+    .replace(/{([^}]+)}/g, "");
+}
+
+function generateFormMethod(
+  groupDetailClean: string,
+  mutations: string,
+): string {
+  return `
+export function useUpdate${groupDetailClean}Form<
+  TFormValues extends object,
+  TPostParams,
+  TPutParams,
+  TPatchParams,
+  TPostPayload,
+  TPutPayload,
+  TPatchPayload,
+  TPostResult,
+  TPutResult,
+  TPatchResult,
+  TFormUpdate extends FormUpdate,
+  TSourceId extends string | undefined,
+>({
+  id,
+  sourceData = {},
+  formValues,
+  formatResponse,
+  transformRequest,
+  transformResponse,
+  mutations = {
+    ${mutations}
+  },
+  updateType,
+  onSuccess
+}: FormProps<
+  TFormValues,
+  TPostParams,
+  TPutParams,
+  TPatchParams,
+  TPostPayload,
+  TPutPayload,
+  TPatchPayload,
+  TPostResult,
+  TPutResult,
+  TPatchResult,
+  TFormUpdate,
+  TSourceId
+>) {
+  return useForm<
+    TFormValues,
+    TPostParams,
+    TPutParams,
+    TPatchParams,
+    TPostPayload,
+    TPutPayload,
+    TPatchPayload,
+    TPostResult,
+    TPutResult,
+    TPatchResult,
+    TFormUpdate,
+    TSourceId
+  >({
+    id,
+    mutations,
+    formValues,
+    sourceData,
+    formatResponse,
+    transformRequest,
+    transformResponse,
+    updateType,
+    onSuccess
+  });
+}`;
+}
+
+function generateMutations(operations: MutationOperations[string]): string {
+  const mutationStrings = [];
+  if (operations.post?.operationId && operations.post?.schema) {
+    mutationStrings.push(`post: {
+      // @ts-ignore
+      mutation: usePost${operations.post.operationId}(),
+      validation: Deref${operations.post.schema}
+    }`);
+  }
+  if (operations.put?.operationId && operations.put?.schema) {
+    mutationStrings.push(`put: {
+      // @ts-ignore
+      mutation: usePut${operations.put.operationId}(),
+      validation: Deref${operations.put.schema}
+    }`);
+  }
+  if (operations.patch?.operationId && operations.patch?.schema) {
+    mutationStrings.push(`patch: {
+      // @ts-ignore
+      mutation: usePatch${operations.patch.operationId}(),
+      validation: Deref${operations.patch.schema}
+    }`);
+  }
+  return mutationStrings.join(",\n    ");
+}

package/src/entity-generation/get-method.ts

@@ -0,0 +1,80 @@
+import { capitaliseFirstLetter } from "../schema/capitalise-first-letter";
+import { toCamelCase } from "../schema/to-camel-case";
+
+export function generateGetAPIMethod(
+  url: string,
+  model: string,
+  operationId: string,
+  responseBody: string | undefined,
+  isList: boolean,
+  pathParameters: string[],
+  requiredParameters: string[],
+  method: string,
+  requestBodySchema: string,
+): [string, Set<string>] {
+  const operationIdUpper = capitaliseFirstLetter(operationId);
+  const paramNames =
+    method === "post" ? `I${requestBodySchema}` : `I${operationIdUpper}Params`;
+  const modelCamel = toCamelCase(model);
+
+  url = url.replace("{", "${");
+
+  const pathParameterString = pathParameters.map((item) => {
+    return `const ${item} = options?.params?.${item};`;
+  });
+
+  const importStatements = new Set<string>();
+
+  if (isList) {
+    importStatements.add(
+      `ListQueryOptions, useGetPaginatedQueryList, useUpdateQuery`,
+    );
+    importStatements.add(paramNames);
+    importStatements.add(responseBody ?? "");
+    return [
+      `
+    export function use${operationIdUpper}(
+  options?: ListQueryOptions<${paramNames}, ${responseBody}>
+) {
+  const { isAuthenticated } = useAuth0();
+  const pathParameters: (keyof ${paramNames})[] = [${pathParameters.map((item) => `'${item}'`).join(", ")}]
+  ${pathParameterString.join("\n")}
+
+  return useGetPaginatedQueryList<${paramNames}, ${responseBody}>({
+    ${method}Url: \`${url}\`,
+    queryKey: ${modelCamel}QueriesKeys.${operationId},
+    pathParameters,
+    isAuthenticated,
+    options,
+  });
+}`,
+      importStatements,
+    ];
+  } else {
+    importStatements.add(`GetQueryOptions, useGetQuery`);
+    importStatements.add(paramNames);
+    importStatements.add(responseBody || "");
+    return [
+      `
+export function use${operationIdUpper}(
+  options?: GetQueryOptions<${paramNames}>
+) {
+  const { isAuthenticated } = useAuth0();
+  const pathParameters: string[] = [${pathParameters.map((item) => `'${item}'`).join(", ")}]
+  ${pathParameterString.join("\n")}
+  const requiredParams: string[] = [${requiredParameters.map((item) => `'${item}'`).join(", ")}]
+  return useGetQuery<${paramNames}, ${responseBody}>({
+    ${method}Url: \`${url}\`,
+    queryKey: ${modelCamel}QueriesKeys.${operationId},
+    //@ts-ignore
+    pathParameters,
+    //@ts-ignore
+    requiredParams,
+    isAuthenticated,
+    options,
+  });
+}`,
+      importStatements,
+    ];
+  }
+}

package/src/entity-generation/imports.ts

@@ -0,0 +1,110 @@
+export function removeDuplicateImports(importStatements: string): string {
+  const importLines = importStatements.split("\n");
+  const uniqueImports = new Set<string>();
+  const radStackImports = new Set<string>();
+  const radSyncImports = new Set<string>();
+  const schemaImports = new Set<string>();
+
+  importLines.forEach((line) => {
+    if (line.includes("rastack/sync")) {
+      const imports =
+        line
+          .match(/\{([^}]+)\}/)?.[1]
+          .split(",")
+          .map((s) => s.trim()) || [];
+      imports.forEach((imp) => radSyncImports.add(imp));
+    } else if (line.includes("rastack/hooks")) {
+      const imports =
+        line
+          .match(/\{([^}]+)\}/)?.[1]
+          .split(",")
+          .map((s) => s.trim()) || [];
+      imports.forEach((imp) => radStackImports.add(imp));
+    } else if (line.includes("@repo/schema/schema")) {
+      const imports =
+        line
+          .match(/\{([^}]+)\}/)?.[1]
+          .split(",")
+          .map((s) => s.trim()) || [];
+      imports.forEach((imp) => schemaImports.add(imp));
+    } else {
+      uniqueImports.add(line);
+    }
+  });
+
+  let result = Array.from(uniqueImports).join("\n") + "\n";
+
+  if (radStackImports.size > 0) {
+    result += `import { ${Array.from(radStackImports).join(", ")} } from 'rastack/hooks';\n`;
+  }
+
+  if (radSyncImports.size > 0) {
+    result += `import { ${Array.from(radSyncImports).join(", ")} } from 'rastack/sync';\n`;
+  }
+
+  if (schemaImports.size > 0) {
+    result += `import { ${Array.from(schemaImports).join(", ")} } from '@repo/schema/schema';\n`;
+  }
+
+  return result;
+}
+
+export function generateImportStatements(
+  importStatements: Set<string>,
+  modelName: string,
+): string {
+  const entries = Array.from(importStatements);
+  const syncImports = entries
+    .filter((importStatement) => importStatement.startsWith("sync:"))
+    .map((importStatement) => importStatement.slice("sync:".length))
+    .join(", ");
+  const queryImports = entries
+    .filter(
+      (importStatement) =>
+        !importStatement.startsWith("sync:") && importStatement.includes("use"),
+    )
+    .join(", ");
+  const schemaImports = entries
+    .filter(
+      (importStatement) =>
+        importStatement.startsWith("I") || importStatement.startsWith("Deref"),
+    )
+    .join(", ");
+
+  let importData =
+    "import { useForm, FormProps, FormUpdate, useUpdateQuery } from 'rastack/hooks';\n";
+  importData = importData + 'import { useAuth0 } from "@auth0/auth0-react";\n';
+  if (queryImports) {
+    importData += `import { ${queryImports} } from 'rastack/hooks';\n`;
+  }
+  if (syncImports) {
+    importData += `import { ${syncImports} } from 'rastack/sync';\n`;
+  }
+  if (schemaImports) {
+    importData += `import { ${schemaImports} } from '@repo/schema/schema';\n`;
+  }
+
+  return removeDuplicateImports(importData);
+}
+
+export function generateKeyImports(model: string, operations: string[]) {
+  model = model.replace(/-([a-z])/g, (g) => g[1].toUpperCase());
+  let keyData = `export const ${model}QueriesKeys = {\n`;
+  operations.forEach((item) => {
+    const snakeCase = item.replace(/([A-Z])/g, "-$1").toLowerCase();
+    keyData += `     ${item}: "${snakeCase}",\n`;
+  });
+  return `${keyData}}`;
+}
+
+export function generateIndexImports(model: string, operations: string[]) {
+  return `export * from "./api"`;
+}
+
+export function generateFolderImports(models: string[]) {
+  let importData = "";
+  models.map((model) => {
+    importData += `export * from "./${model}"\n`;
+  });
+  return importData;
+}

package/src/entity-generation/sync-method.ts

@@ -0,0 +1,222 @@
+import { capitaliseFirstLetter } from "../schema/capitalise-first-letter";
+import { toCamelCase } from "../schema/to-camel-case";
+
+/**
+ * Generators for sync-mode entities (operations carrying the
+ * `x-rastack-sync` OpenAPI extension emitted by rastack). Reads bind to the
+ * local store, writes enqueue optimistic transactions, and operations the
+ * fat class marked as confirmed become blocking online-only mutations.
+ *
+ * Imports prefixed with "sync:" are routed to 'rastack/sync' by
+ * generateImportStatements.
+ */
+
+export interface EntitySyncMeta {
+  sync: boolean;
+  /** Sync.load = "lazy": excluded from initial bootstrap, loaded on first use. */
+  lazy?: boolean;
+  /** Sync.client_ids = True: rows use client-generated UUID primary keys. */
+  clientIds?: boolean;
+  confirmedOperationIds: Set<string>;
+  listUrl?: string;
+  detailUrl?: string;
+  detailParam?: string;
+  listOperationId?: string;
+  detailOperationId?: string;
+  rowSchema?: string; // e.g. "IPet"
+}
+
+export function entityConstName(model: string): string {
+  return `${toCamelCase(model)}Entity`;
+}
+
+export function generateEntityDescriptor(
+  appName: string,
+  modelName: string,
+  meta: EntitySyncMeta,
+): [string, Set<string>] {
+  const importStatements = new Set<string>();
+  importStatements.add("sync:defineEntity");
+  if (meta.rowSchema) {
+    importStatements.add(meta.rowSchema);
+  }
+  const rowType = meta.rowSchema || "any";
+  const listUrl =
+    meta.listUrl ||
+    (meta.detailUrl ? meta.detailUrl.replace(/\/?\{[^}]+\}.*$/, "") : "");
+  const detailUrl = meta.detailUrl
+    ? meta.detailUrl.replace(/\{[^}]+\}/, "${id}")
+    : `${listUrl.replace(/\/$/, "")}/\${id}`;
+
+  const lazyLine = meta.lazy ? `\n  lazy: true,` : "";
+  const clientIdsLine = meta.clientIds ? `\n  clientIds: true,` : "";
+
+  return [
+    `
+export const ${entityConstName(modelName)} = defineEntity<${rowType}>({
+  app: "${appName}",
+  model: "${modelName}",
+  listUrl: \`${listUrl}\`,
+  detailUrl: (id) => \`${detailUrl}\`,${lazyLine}${clientIdsLine}
+});
+`,
+    importStatements,
+  ];
+}
+
+export function generateSyncListMethod(
+  modelName: string,
+  operationId: string,
+  rowSchema: string | undefined,
+): [string, Set<string>] {
+  const operationIdUpper = capitaliseFirstLetter(operationId);
+  const rowType = rowSchema || "any";
+  const importStatements = new Set<string>();
+  importStatements.add("sync:useEntityList");
+  importStatements.add("sync:EntityListOptions");
+  if (rowSchema) {
+    importStatements.add(rowSchema);
+  }
+  return [
+    `
+export function use${operationIdUpper}(
+  options?: EntityListOptions<${rowType}>
+) {
+  return useEntityList<${rowType}>(${entityConstName(modelName)}, options);
+}`,
+    importStatements,
+  ];
+}
+
+export function generateSyncRecordMethod(
+  modelName: string,
+  operationId: string,
+  rowSchema: string | undefined,
+  pathParameters: string[],
+): [string, Set<string>] {
+  const operationIdUpper = capitaliseFirstLetter(operationId);
+  const rowType = rowSchema || "any";
+  const paramNames = `I${operationIdUpper}Params`;
+  const idParam = pathParameters[0];
+  const importStatements = new Set<string>();
+  importStatements.add("sync:useEntityRecord");
+  importStatements.add(`GetQueryOptions, useGetQuery`);
+  importStatements.add(paramNames);
+  if (rowSchema) {
+    importStatements.add(rowSchema);
+  }
+  return [
+    `
+export function use${operationIdUpper}(
+  options?: GetQueryOptions<${paramNames}>
+) {
+  const id = options?.params?.${idParam};
+  return useEntityRecord<${rowType}>(${entityConstName(modelName)}, id as string | number | undefined);
+}`,
+    importStatements,
+  ];
+}
+
+export function generateSyncUpdateMethod(
+  url: string,
+  method: string,
+  modelName: string,
+  operationId: string,
+  requestBody: string | undefined,
+  responseBody: string | undefined,
+  pathParameters: string[],
+): [string, Set<string>] {
+  const operationIdUpper = capitaliseFirstLetter(operationId);
+  const paramNames = `I${operationIdUpper}Params`;
+  const methodUpper = method.charAt(0).toUpperCase() + method.slice(1);
+  const isCreate = pathParameters.length === 0;
+  const idParam = pathParameters[0];
+
+  let urlStructure = url.replace(/{([^}]+)}/g, "${params.$1}");
+  urlStructure = `(params) => \`${urlStructure}\``;
+
+  const importStatements = new Set<string>();
+  importStatements.add("sync:useEntityMutation");
+  importStatements.add(paramNames);
+  if (requestBody) {
+    importStatements.add(requestBody);
+  }
+  if (responseBody) {
+    importStatements.add(responseBody);
+  }
+
+  const idLine = isCreate
+    ? ""
+    : `\n    id: (params) => params.${idParam} as string | number | undefined,`;
+
+  return [
+    `
+export function use${methodUpper}${operationIdUpper}() {
+  return useEntityMutation<${paramNames}, ${requestBody || "any"}, ${responseBody || "any"}>(${entityConstName(modelName)}, {
+    op: "${isCreate ? "create" : "update"}",
+    method: "${method}",
+    url: ${urlStructure},${idLine}
+  });
+}`,
+    importStatements,
+  ];
+}
+
+export function generateSyncDeleteMethod(
+  url: string,
+  modelName: string,
+  operationId: string,
+): [string, Set<string>] {
+  const operationIdUpper = capitaliseFirstLetter(operationId);
+  const urlStructure = url.replace(/{[^}]+}/, "${id}");
+  const importStatements = new Set<string>();
+  importStatements.add("sync:useEntityDelete");
+
+  return [
+    `
+export function use${operationIdUpper}() {
+  return useEntityDelete(${entityConstName(modelName)}, {
+    url: (id) => \`${urlStructure}\`,
+  });
+}
+`,
+    importStatements,
+  ];
+}
+
+export function generateConfirmedMethod(
+  url: string,
+  method: string,
+  operationId: string,
+  requestBody: string | undefined,
+  responseBody: string | undefined,
+): [string, Set<string>] {
+  const operationIdUpper = capitaliseFirstLetter(operationId);
+  const paramNames = `I${operationIdUpper}Params`;
+  const methodUpper = method.charAt(0).toUpperCase() + method.slice(1);
+
+  let urlStructure = url.replace(/{([^}]+)}/g, "${params.$1}");
+  urlStructure = `(params) => \`${urlStructure}\``;
+
+  const importStatements = new Set<string>();
+  importStatements.add("sync:useConfirmedMutation");
+  importStatements.add(paramNames);
+  if (requestBody) {
+    importStatements.add(requestBody);
+  }
+  if (responseBody) {
+    importStatements.add(responseBody);
+  }
+
+  return [
+    `
+// Confirmed ("sync") operation: blocking, online-only, no optimistic apply.
+export function use${methodUpper}${operationIdUpper}() {
+  return useConfirmedMutation<${paramNames}, ${requestBody || "any"}, ${responseBody || "any"}>({
+    method: "${method}",
+    url: ${urlStructure},
+  });
+}`,
+    importStatements,
+  ];
+}

package/src/entity-generation/update-method.ts

@@ -0,0 +1,38 @@
+import { capitaliseFirstLetter } from "../schema/capitalise-first-letter";
+
+export function generateUpdateAPIMethod(
+  url: string,
+  method: string,
+  operationId: string,
+  requestBody: string | undefined,
+  responseBody: string | undefined,
+  listQueryCacheKey?: string,
+  itemQueryCacheKey?: string,
+): [string, Set<string>] {
+  const operationIdUpper = capitaliseFirstLetter(operationId);
+  const paramNames = `I${operationIdUpper}Params`;
+
+  let urlStructure = url.replace(/{([^}]+)}/g, "${params.$1}");
+  urlStructure = `(params) => \`${urlStructure}\``;
+
+  const methodUpper = method.charAt(0).toUpperCase() + method.slice(1);
+  const importStatements = new Set<string>();
+  importStatements.add(paramNames ?? "");
+  importStatements.add(requestBody ?? "");
+  importStatements.add(responseBody ?? "");
+
+  const cacheKeyLines = [
+    listQueryCacheKey ? `\n    listQueryCacheKey: ${listQueryCacheKey},` : "",
+    itemQueryCacheKey ? `\n    itemQueryCacheKey: ${itemQueryCacheKey},` : "",
+  ].join("");
+
+  return [
+    `
+export function use${methodUpper}${operationIdUpper}() {
+  return useUpdateQuery<${paramNames}, ${requestBody}, ${responseBody}>({
+    ${method}Url: ${urlStructure},${cacheKeyLines}
+  });
+}`,
+    importStatements,
+  ];
+}

package/src/index.ts

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+
+import path from "path";
+import fs from "fs";
+import { execSync } from "child_process";
+
+const args = process.argv.slice(2);
+const schemaOnly = args.includes("--schema-only");
+
+const currentDir = process.cwd(); // Get the current working directory
+const kodeDir = path.join(currentDir, ".kode");
+const configFile = path.join(kodeDir, "generate-rad-sdk.json");
+let config: any = {};
+
+// Create the .kode directory if it doesn't exist
+if (!fs.existsSync(kodeDir)) {
+  fs.mkdirSync(kodeDir);
+}
+
+// If the generate-schema-sdk-config.json file doesn't exist, create it with default values
+if (!fs.existsSync(configFile)) {
+  config = {
+    schemaUrl: "http://127.0.0.1:8000/api/schema/",
+  };
+  fs.writeFileSync(configFile, JSON.stringify(config, null, 2));
+} else {
+  config = JSON.parse(fs.readFileSync(configFile, "utf-8"));
+}
+
+const projectPath = currentDir;
+const schemaUrl = config.schemaUrl;
+
+// Execute the script commands and print the output
+const schemaFetchOutput = execSync(
+  `node ${__dirname}/schema-fetch.js ${schemaUrl} ${projectPath}/packages/schema/schema/`,
+).toString();
+console.log(schemaFetchOutput);
+
+const schemaConvertOutput = execSync(
+  `node ${__dirname}/schema-convert.js ${projectPath}/packages/schema/schema/`,
+).toString();
+console.log(schemaConvertOutput);
+
+process.chdir(`${projectPath}/packages/schema/schema/api-schema`);
+const schemaFullOutput = execSync(
+  `node ${__dirname}/schema-full.js ${projectPath}/packages/schema/schema/`,
+).toString();
+console.log(schemaFullOutput);
+
+process.chdir(__dirname);
+const schemaParamsOutput = execSync(
+  `node ${__dirname}/schema-params.js ${schemaUrl} ${projectPath}/packages/schema/schema/`,
+).toString();
+console.log(schemaParamsOutput);
+
+const schemaIndexOutput = execSync(
+  `node ${__dirname}/schema-index.js ${projectPath}/packages/schema/schema/`,
+).toString();
+console.log(schemaIndexOutput);
+
+if (!schemaOnly) {
+  // Generate entities if --schema-only flag is not provided
+  const schemaEntitiesOutput = execSync(
+    `node ${__dirname}/schema-entities.js ${schemaUrl} ${projectPath}/packages/entities/`,
+  ).toString();
+  console.log(schemaEntitiesOutput);
+}
+
+const prettierSchemaOutput = execSync(
+  `${projectPath}/node_modules/.bin/prettier --write --config .prettierrc ${projectPath}/packages/schema/schema/`,
+).toString();
+console.log(prettierSchemaOutput);
+
+const prettierEntitiesOutput = execSync(
+  `${projectPath}/node_modules/.bin/prettier --write --config .prettierrc ${projectPath}/packages/entities/`,
+).toString();
+console.log(prettierEntitiesOutput);