rastack 0.0.16

package/dist/entity-generation/delete-method.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDeleteAPIMethod = void 0;
+const capitalise_first_letter_1 = require("../schema/capitalise-first-letter");
+function generateDeleteAPIMethod(url, operationId, listQueryCacheKey) {
+    var _a;
+    const operationIdUpper = (0, capitalise_first_letter_1.capitaliseFirstLetter)(operationId);
+    let urlStructure = `'${url}'`;
+    const pathParams = ((_a = url.match(/{([^}]+)}/g)) === null || _a === void 0 ? void 0 : _a.map((param) => param.slice(1, -1))) || [];
+    if (pathParams.length > 0) {
+        urlStructure = url.replace(/{([^}]+)}/g, "${$1}");
+        const paramList = pathParams.join(", ");
+        urlStructure = `(${paramList}) => \`${urlStructure}\``;
+    }
+    const importStatements = new Set();
+    importStatements.add(`useDeleteQuery`);
+    const cacheKeyLine = listQueryCacheKey
+        ? `\n    listQueryCacheKey: ${listQueryCacheKey},`
+        : "";
+    return [
+        `
+export function use${operationIdUpper}() {
+  return useDeleteQuery({
+    deleteUrl: ${urlStructure},${cacheKeyLine}
+  });
+}
+`,
+        importStatements,
+    ];
+}
+exports.generateDeleteAPIMethod = generateDeleteAPIMethod;

package/dist/entity-generation/form.d.ts

@@ -0,0 +1,13 @@
+type MutationOperation = {
+    operationId: string;
+    schema: string;
+};
+type MutationOperations = {
+    [path: string]: {
+        put?: MutationOperation;
+        post?: MutationOperation;
+        patch?: MutationOperation;
+    };
+};
+export declare function generateUpdateFormMethod(appName: string, modelName: string, mutationOperations: MutationOperations): (string | Set<string>)[];
+export {};

package/dist/entity-generation/form.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateUpdateFormMethod = void 0;
+const to_pastel_case_1 = require("../schema/to-pastel-case");
+function generateUpdateFormMethod(appName, modelName, mutationOperations) {
+    const modelDetail = (0, to_pastel_case_1.toPascalCase)(modelName);
+    const importStatements = new Set();
+    const groupedMutations = {};
+    Object.entries(mutationOperations).forEach(([path, operations]) => {
+        const pathParts = path.split("/");
+        const groupDetail = (0, to_pastel_case_1.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];
+}
+exports.generateUpdateFormMethod = generateUpdateFormMethod;
+function cleanGroupDetail(groupDetail) {
+    return groupDetail
+        .replace("V1", "")
+        .split("_")
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join("")
+        .replace(/{([^}]+)}/g, "");
+}
+function generateFormMethod(groupDetailClean, mutations) {
+    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) {
+    var _a, _b, _c, _d, _e, _f;
+    const mutationStrings = [];
+    if (((_a = operations.post) === null || _a === void 0 ? void 0 : _a.operationId) && ((_b = operations.post) === null || _b === void 0 ? void 0 : _b.schema)) {
+        mutationStrings.push(`post: {
+      // @ts-ignore
+      mutation: usePost${operations.post.operationId}(),
+      validation: Deref${operations.post.schema}
+    }`);
+    }
+    if (((_c = operations.put) === null || _c === void 0 ? void 0 : _c.operationId) && ((_d = operations.put) === null || _d === void 0 ? void 0 : _d.schema)) {
+        mutationStrings.push(`put: {
+      // @ts-ignore
+      mutation: usePut${operations.put.operationId}(),
+      validation: Deref${operations.put.schema}
+    }`);
+    }
+    if (((_e = operations.patch) === null || _e === void 0 ? void 0 : _e.operationId) && ((_f = operations.patch) === null || _f === void 0 ? void 0 : _f.schema)) {
+        mutationStrings.push(`patch: {
+      // @ts-ignore
+      mutation: usePatch${operations.patch.operationId}(),
+      validation: Deref${operations.patch.schema}
+    }`);
+    }
+    return mutationStrings.join(",\n    ");
+}

package/dist/entity-generation/get-method.d.ts

@@ -0,0 +1 @@
+export declare function generateGetAPIMethod(url: string, model: string, operationId: string, responseBody: string | undefined, isList: boolean, pathParameters: string[], requiredParameters: string[], method: string, requestBodySchema: string): [string, Set<string>];

package/dist/entity-generation/get-method.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateGetAPIMethod = void 0;
+const capitalise_first_letter_1 = require("../schema/capitalise-first-letter");
+const to_camel_case_1 = require("../schema/to-camel-case");
+function generateGetAPIMethod(url, model, operationId, responseBody, isList, pathParameters, requiredParameters, method, requestBodySchema) {
+    const operationIdUpper = (0, capitalise_first_letter_1.capitaliseFirstLetter)(operationId);
+    const paramNames = method === "post" ? `I${requestBodySchema}` : `I${operationIdUpper}Params`;
+    const modelCamel = (0, to_camel_case_1.toCamelCase)(model);
+    url = url.replace("{", "${");
+    const pathParameterString = pathParameters.map((item) => {
+        return `const ${item} = options?.params?.${item};`;
+    });
+    const importStatements = new Set();
+    if (isList) {
+        importStatements.add(`ListQueryOptions, useGetPaginatedQueryList, useUpdateQuery`);
+        importStatements.add(paramNames);
+        importStatements.add(responseBody !== null && responseBody !== void 0 ? 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,
+        ];
+    }
+}
+exports.generateGetAPIMethod = generateGetAPIMethod;

package/dist/entity-generation/imports.d.ts

@@ -0,0 +1,5 @@
+export declare function removeDuplicateImports(importStatements: string): string;
+export declare function generateImportStatements(importStatements: Set<string>, modelName: string): string;
+export declare function generateKeyImports(model: string, operations: string[]): string;
+export declare function generateIndexImports(model: string, operations: string[]): string;
+export declare function generateFolderImports(models: string[]): string;

package/dist/entity-generation/imports.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateFolderImports = exports.generateIndexImports = exports.generateKeyImports = exports.generateImportStatements = exports.removeDuplicateImports = void 0;
+function removeDuplicateImports(importStatements) {
+    const importLines = importStatements.split("\n");
+    const uniqueImports = new Set();
+    const radStackImports = new Set();
+    const radSyncImports = new Set();
+    const schemaImports = new Set();
+    importLines.forEach((line) => {
+        var _a, _b, _c;
+        if (line.includes("rad-stack/sync")) {
+            const imports = ((_a = line
+                .match(/\{([^}]+)\}/)) === null || _a === void 0 ? void 0 : _a[1].split(",").map((s) => s.trim())) || [];
+            imports.forEach((imp) => radSyncImports.add(imp));
+        }
+        else if (line.includes("rad-stack/hooks")) {
+            const imports = ((_b = line
+                .match(/\{([^}]+)\}/)) === null || _b === void 0 ? void 0 : _b[1].split(",").map((s) => s.trim())) || [];
+            imports.forEach((imp) => radStackImports.add(imp));
+        }
+        else if (line.includes("@repo/schema/schema")) {
+            const imports = ((_c = line
+                .match(/\{([^}]+)\}/)) === null || _c === void 0 ? void 0 : _c[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 'rad-stack/hooks';\n`;
+    }
+    if (radSyncImports.size > 0) {
+        result += `import { ${Array.from(radSyncImports).join(", ")} } from 'rad-stack/sync';\n`;
+    }
+    if (schemaImports.size > 0) {
+        result += `import { ${Array.from(schemaImports).join(", ")} } from '@repo/schema/schema';\n`;
+    }
+    return result;
+}
+exports.removeDuplicateImports = removeDuplicateImports;
+function generateImportStatements(importStatements, modelName) {
+    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 'rad-stack/hooks';\n";
+    importData = importData + 'import { useAuth0 } from "@auth0/auth0-react";\n';
+    if (queryImports) {
+        importData += `import { ${queryImports} } from 'rad-stack/hooks';\n`;
+    }
+    if (syncImports) {
+        importData += `import { ${syncImports} } from 'rad-stack/sync';\n`;
+    }
+    if (schemaImports) {
+        importData += `import { ${schemaImports} } from '@repo/schema/schema';\n`;
+    }
+    return removeDuplicateImports(importData);
+}
+exports.generateImportStatements = generateImportStatements;
+function generateKeyImports(model, operations) {
+    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}}`;
+}
+exports.generateKeyImports = generateKeyImports;
+function generateIndexImports(model, operations) {
+    return `export * from "./api"`;
+}
+exports.generateIndexImports = generateIndexImports;
+function generateFolderImports(models) {
+    let importData = "";
+    models.map((model) => {
+        importData += `export * from "./${model}"\n`;
+    });
+    return importData;
+}
+exports.generateFolderImports = generateFolderImports;

package/dist/entity-generation/sync-method.d.ts

@@ -0,0 +1,30 @@
+/**
+ * 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 'rad-stack/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;
+}
+export declare function entityConstName(model: string): string;
+export declare function generateEntityDescriptor(appName: string, modelName: string, meta: EntitySyncMeta): [string, Set<string>];
+export declare function generateSyncListMethod(modelName: string, operationId: string, rowSchema: string | undefined): [string, Set<string>];
+export declare function generateSyncRecordMethod(modelName: string, operationId: string, rowSchema: string | undefined, pathParameters: string[]): [string, Set<string>];
+export declare function generateSyncUpdateMethod(url: string, method: string, modelName: string, operationId: string, requestBody: string | undefined, responseBody: string | undefined, pathParameters: string[]): [string, Set<string>];
+export declare function generateSyncDeleteMethod(url: string, modelName: string, operationId: string): [string, Set<string>];
+export declare function generateConfirmedMethod(url: string, method: string, operationId: string, requestBody: string | undefined, responseBody: string | undefined): [string, Set<string>];

package/dist/entity-generation/sync-method.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateConfirmedMethod = exports.generateSyncDeleteMethod = exports.generateSyncUpdateMethod = exports.generateSyncRecordMethod = exports.generateSyncListMethod = exports.generateEntityDescriptor = exports.entityConstName = void 0;
+const capitalise_first_letter_1 = require("../schema/capitalise-first-letter");
+const to_camel_case_1 = require("../schema/to-camel-case");
+function entityConstName(model) {
+    return `${(0, to_camel_case_1.toCamelCase)(model)}Entity`;
+}
+exports.entityConstName = entityConstName;
+function generateEntityDescriptor(appName, modelName, meta) {
+    const importStatements = new Set();
+    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,
+    ];
+}
+exports.generateEntityDescriptor = generateEntityDescriptor;
+function generateSyncListMethod(modelName, operationId, rowSchema) {
+    const operationIdUpper = (0, capitalise_first_letter_1.capitaliseFirstLetter)(operationId);
+    const rowType = rowSchema || "any";
+    const importStatements = new Set();
+    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,
+    ];
+}
+exports.generateSyncListMethod = generateSyncListMethod;
+function generateSyncRecordMethod(modelName, operationId, rowSchema, pathParameters) {
+    const operationIdUpper = (0, capitalise_first_letter_1.capitaliseFirstLetter)(operationId);
+    const rowType = rowSchema || "any";
+    const paramNames = `I${operationIdUpper}Params`;
+    const idParam = pathParameters[0];
+    const importStatements = new Set();
+    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,
+    ];
+}
+exports.generateSyncRecordMethod = generateSyncRecordMethod;
+function generateSyncUpdateMethod(url, method, modelName, operationId, requestBody, responseBody, pathParameters) {
+    const operationIdUpper = (0, capitalise_first_letter_1.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();
+    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,
+    ];
+}
+exports.generateSyncUpdateMethod = generateSyncUpdateMethod;
+function generateSyncDeleteMethod(url, modelName, operationId) {
+    const operationIdUpper = (0, capitalise_first_letter_1.capitaliseFirstLetter)(operationId);
+    const urlStructure = url.replace(/{[^}]+}/, "${id}");
+    const importStatements = new Set();
+    importStatements.add("sync:useEntityDelete");
+    return [
+        `
+export function use${operationIdUpper}() {
+  return useEntityDelete(${entityConstName(modelName)}, {
+    url: (id) => \`${urlStructure}\`,
+  });
+}
+`,
+        importStatements,
+    ];
+}
+exports.generateSyncDeleteMethod = generateSyncDeleteMethod;
+function generateConfirmedMethod(url, method, operationId, requestBody, responseBody) {
+    const operationIdUpper = (0, capitalise_first_letter_1.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();
+    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,
+    ];
+}
+exports.generateConfirmedMethod = generateConfirmedMethod;

package/dist/entity-generation/update-method.d.ts

@@ -0,0 +1 @@
+export declare function generateUpdateAPIMethod(url: string, method: string, operationId: string, requestBody: string | undefined, responseBody: string | undefined, listQueryCacheKey?: string, itemQueryCacheKey?: string): [string, Set<string>];

package/dist/entity-generation/update-method.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateUpdateAPIMethod = void 0;
+const capitalise_first_letter_1 = require("../schema/capitalise-first-letter");
+function generateUpdateAPIMethod(url, method, operationId, requestBody, responseBody, listQueryCacheKey, itemQueryCacheKey) {
+    const operationIdUpper = (0, capitalise_first_letter_1.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();
+    importStatements.add(paramNames !== null && paramNames !== void 0 ? paramNames : "");
+    importStatements.add(requestBody !== null && requestBody !== void 0 ? requestBody : "");
+    importStatements.add(responseBody !== null && responseBody !== void 0 ? 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,
+    ];
+}
+exports.generateUpdateAPIMethod = generateUpdateAPIMethod;

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const child_process_1 = require("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_1.default.join(currentDir, ".kode");
+const configFile = path_1.default.join(kodeDir, "generate-rad-sdk.json");
+let config = {};
+// Create the .kode directory if it doesn't exist
+if (!fs_1.default.existsSync(kodeDir)) {
+    fs_1.default.mkdirSync(kodeDir);
+}
+// If the generate-schema-sdk-config.json file doesn't exist, create it with default values
+if (!fs_1.default.existsSync(configFile)) {
+    config = {
+        schemaUrl: "http://127.0.0.1:8000/api/schema/",
+    };
+    fs_1.default.writeFileSync(configFile, JSON.stringify(config, null, 2));
+}
+else {
+    config = JSON.parse(fs_1.default.readFileSync(configFile, "utf-8"));
+}
+const projectPath = currentDir;
+const schemaUrl = config.schemaUrl;
+// Execute the script commands and print the output
+const schemaFetchOutput = (0, child_process_1.execSync)(`node ${__dirname}/schema-fetch.js ${schemaUrl} ${projectPath}/packages/schema/schema/`).toString();
+console.log(schemaFetchOutput);
+const schemaConvertOutput = (0, child_process_1.execSync)(`node ${__dirname}/schema-convert.js ${projectPath}/packages/schema/schema/`).toString();
+console.log(schemaConvertOutput);
+process.chdir(`${projectPath}/packages/schema/schema/api-schema`);
+const schemaFullOutput = (0, child_process_1.execSync)(`node ${__dirname}/schema-full.js ${projectPath}/packages/schema/schema/`).toString();
+console.log(schemaFullOutput);
+process.chdir(__dirname);
+const schemaParamsOutput = (0, child_process_1.execSync)(`node ${__dirname}/schema-params.js ${schemaUrl} ${projectPath}/packages/schema/schema/`).toString();
+console.log(schemaParamsOutput);
+const schemaIndexOutput = (0, child_process_1.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 = (0, child_process_1.execSync)(`node ${__dirname}/schema-entities.js ${schemaUrl} ${projectPath}/packages/entities/`).toString();
+    console.log(schemaEntitiesOutput);
+}
+const prettierSchemaOutput = (0, child_process_1.execSync)(`${projectPath}/node_modules/.bin/prettier --write --config .prettierrc ${projectPath}/packages/schema/schema/`).toString();
+console.log(prettierSchemaOutput);
+const prettierEntitiesOutput = (0, child_process_1.execSync)(`${projectPath}/node_modules/.bin/prettier --write --config .prettierrc ${projectPath}/packages/entities/`).toString();
+console.log(prettierEntitiesOutput);

package/dist/rad-compile.d.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+/**
+ * `rad compile | check | list | urls` — the TypeScript-first replacement for the
+ * old Django `manage.py rastack` command.
+ *
+ *   rad compile [resourcesDir] [outDir]   defs → schema.rad.json + openapi.json
+ *   rad check   [resourcesDir]            validate the resource graph (exit != 0 on error)
+ *   rad list    [resourcesDir]            print every resource + its fields/relations
+ *   rad urls    [resourcesDir]            print the generated /api/{app}/v1/{model}/ routes
+ */
+export {};