rastack 0.0.16

package/dist/schema-entities.js

@@ -0,0 +1,293 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = exports.generateFiles = exports.generateFolders = exports.collectEntityMeta = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const extract_response_1 = require("./schema/extract-response");
+const fetch_schema_1 = require("./schema/fetch-schema");
+const remove_non_model_paths_1 = require("./schema/remove-non-model-paths");
+const camel_to_pastel_1 = require("./schema/camel-to-pastel");
+const get_method_1 = require("./entity-generation/get-method");
+const update_method_1 = require("./entity-generation/update-method");
+const imports_1 = require("./entity-generation/imports");
+const form_1 = require("./entity-generation/form");
+const delete_method_1 = require("./entity-generation/delete-method");
+const sync_method_1 = require("./entity-generation/sync-method");
+const to_camel_case_1 = require("./schema/to-camel-case");
+function pathSegments(pathKey) {
+    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).
+ */
+function collectEntityMeta(paths) {
+    const meta = {};
+    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];
+            const syncExtension = operation["x-rastack-sync"];
+            if (syncExtension === "local" || syncExtension === "confirmed") {
+                entityMeta.sync = true;
+            }
+            if (operation["x-rastack-sync-load"] === "lazy") {
+                entityMeta.lazy = true;
+            }
+            if (operation["x-rastack-sync-client-ids"] === true) {
+                entityMeta.clientIds = true;
+            }
+            if (syncExtension === "confirmed" && operation.operationId) {
+                entityMeta.confirmedOperationIds.add(operation.operationId);
+            }
+            const [responseBodySchema, isList] = (0, extract_response_1.extractResponseBodySchema)(operation);
+            const operationId = operation.operationId || "";
+            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;
+}
+exports.collectEntityMeta = collectEntityMeta;
+function generateFolders(entitiesPath, paths) {
+    return __awaiter(this, void 0, void 0, function* () {
+        Object.keys(paths).forEach((key) => {
+            const appName = key.split("/")[2];
+            const modelName = key.split("/")[4];
+            const appFolder = (0, path_1.join)(entitiesPath, appName);
+            const modelFolder = (0, path_1.join)(appFolder, modelName);
+            (0, fs_1.mkdirSync)(appFolder, { recursive: true });
+            (0, fs_1.mkdirSync)(modelFolder, { recursive: true });
+        });
+    });
+}
+exports.generateFolders = generateFolders;
+function generateFiles(entitiesPath, paths) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const uniqueOperationNames = [];
+        const modelFileImports = {};
+        const modelFileData = {};
+        const keysFileData = {};
+        const modelImportsFileData = {};
+        const formMutationOperations = {};
+        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) => {
+                var _a, _b, _c, _d;
+                // @ts-ignore
+                const methodInformation = paths[pathKey][method];
+                const methodParameters = methodInformation.parameters;
+                const pathParameters = methodParameters
+                    ? methodParameters
+                        .filter((item) => item.required)
+                        .filter((item) => item.in === "path")
+                        .map((item) => item.name)
+                    : [];
+                const requestBody = methodInformation.requestBody;
+                // @ts-ignore
+                const requestBodySchema = (_c = (_b = (_a = requestBody === null || requestBody === void 0 ? void 0 : requestBody.content) === null || _a === void 0 ? void 0 : _a["application/json"]) === null || _b === void 0 ? void 0 : _b.schema["$ref"]) === null || _c === void 0 ? void 0 : _c.replace("#/components/schemas/", "");
+                let [responseBodySchema, isList] = (0, extract_response_1.extractResponseBodySchema)(methodInformation);
+                const requiredParameters = methodParameters
+                    ? methodParameters
+                        .filter((item) => item.required)
+                        .map((item) => item.name)
+                    : [];
+                const operationId = methodInformation.operationId;
+                if (!uniqueOperationNames.includes(operationId)) {
+                    uniqueOperationNames.push(operationId);
+                    let apiMethods = "";
+                    let importStatements = new Set();
+                    const isPostListEndpoint = method === "post" &&
+                        (operationId.includes("List") || operationId.includes("list"));
+                    const isListEndpoint = isList || isPostListEndpoint;
+                    const meta = entityMeta[indexKey];
+                    const isSyncEntity = (meta === null || meta === void 0 ? void 0 : meta.sync) === true;
+                    const isConfirmedOperation = methodInformation["x-rastack-sync"] === "confirmed" &&
+                        method !== "get";
+                    const modelCamel = (0, to_camel_case_1.toCamelCase)(modelName);
+                    const listKeyRef = (meta === null || meta === void 0 ? void 0 : meta.listOperationId)
+                        ? `${modelCamel}QueriesKeys.${meta.listOperationId}`
+                        : undefined;
+                    const itemKeyRef = (meta === null || meta === void 0 ? void 0 : meta.detailOperationId)
+                        ? `${modelCamel}QueriesKeys.${meta.detailOperationId}`
+                        : undefined;
+                    if (isConfirmedOperation) {
+                        [apiMethods, importStatements] = (0, sync_method_1.generateConfirmedMethod)(pathKey, method, operationId, requestBodySchema ? `I${requestBodySchema}` : undefined, responseBodySchema ? `I${responseBodySchema}` : undefined);
+                        formMutationOperations[indexKey] = Object.assign(Object.assign({}, formMutationOperations[indexKey]), { [pathKey]: {
+                                [method]: {
+                                    operationId: (0, camel_to_pastel_1.camelToPastel)(operationId),
+                                    schema: requestBodySchema ? `I${requestBodySchema}` : "",
+                                },
+                            } });
+                    }
+                    else if (method === "get" || isPostListEndpoint) {
+                        if (isSyncEntity && isListEndpoint) {
+                            [apiMethods, importStatements] = (0, sync_method_1.generateSyncListMethod)(modelName, operationId, meta.rowSchema);
+                        }
+                        else if (isSyncEntity && pathKey.includes("{")) {
+                            const urlParams = ((_d = pathKey.match(/{([^}]+)}/g)) === null || _d === void 0 ? void 0 : _d.map((param) => param.slice(1, -1))) ||
+                                [];
+                            [apiMethods, importStatements] = (0, sync_method_1.generateSyncRecordMethod)(modelName, operationId, meta.rowSchema, pathParameters.length > 0 ? pathParameters : urlParams);
+                        }
+                        else {
+                            [apiMethods, importStatements] = (0, get_method_1.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] = (0, sync_method_1.generateSyncUpdateMethod)(pathKey, method, modelName, operationId, requestBodySchema ? `I${requestBodySchema}` : undefined, responseBodySchema ? `I${responseBodySchema}` : undefined, pathParameters);
+                        }
+                        else {
+                            [apiMethods, importStatements] = (0, update_method_1.generateUpdateAPIMethod)(pathKey, method, operationId, requestBodySchema ? `I${requestBodySchema}` : undefined, responseBodySchema ? `I${responseBodySchema}` : undefined, listKeyRef, itemKeyRef);
+                        }
+                        formMutationOperations[indexKey] = Object.assign(Object.assign({}, formMutationOperations[indexKey]), { [pathKey]: {
+                                [method]: {
+                                    operationId: (0, camel_to_pastel_1.camelToPastel)(operationId),
+                                    schema: requestBodySchema ? `I${requestBodySchema}` : "",
+                                },
+                            } });
+                    }
+                    else if (method === "delete") {
+                        if (isSyncEntity) {
+                            [apiMethods, importStatements] = (0, sync_method_1.generateSyncDeleteMethod)(pathKey, modelName, operationId);
+                        }
+                        else {
+                            [apiMethods, importStatements] = (0, delete_method_1.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) => {
+            var _a;
+            const [appName, modelName] = key.split("|");
+            const modelFolder = (0, path_1.join)(entitiesPath, appName, modelName);
+            const apiFile = (0, path_1.join)(modelFolder, "api.ts");
+            const indexFile = (0, path_1.join)(modelFolder, "index.ts");
+            const keyImports = (0, imports_1.generateKeyImports)(modelName, keysFileData[key]);
+            const [updateFormMethod, importStatements] = (0, form_1.generateUpdateFormMethod)(appName, modelName, formMutationOperations[key]);
+            const indexKey = `${appName}|${modelName}`;
+            modelFileImports[indexKey] = new Set([
+                ...(modelFileImports[indexKey] || []),
+                ...importStatements,
+            ]);
+            let entityDescriptor = "";
+            if ((_a = entityMeta[key]) === null || _a === void 0 ? void 0 : _a.sync) {
+                const [descriptorCode, descriptorImports] = (0, sync_method_1.generateEntityDescriptor)(appName, modelName, entityMeta[key]);
+                entityDescriptor = descriptorCode;
+                modelFileImports[indexKey] = new Set([
+                    ...(modelFileImports[indexKey] || []),
+                    ...descriptorImports,
+                ]);
+            }
+            const importData = (0, imports_1.generateImportStatements)(modelFileImports[key], modelName);
+            const apiFileText = `${importData}\n${keyImports}\n${entityDescriptor}${modelFileData[key]}\n${updateFormMethod}`;
+            const indexImports = (0, imports_1.generateIndexImports)(modelName, keysFileData[key]);
+            (0, fs_1.writeFileSync)(apiFile, apiFileText, { flag: "w" });
+            (0, fs_1.writeFileSync)(indexFile, indexImports, { flag: "w" });
+        });
+        // create an index file with all the file names per model
+        Object.keys(modelImportsFileData).forEach((key) => {
+            const modelFolder = (0, path_1.join)(entitiesPath, key);
+            const indexFile = (0, path_1.join)(modelFolder, "index.ts");
+            const indexImports = (0, imports_1.generateFolderImports)(modelImportsFileData[key]);
+            (0, fs_1.writeFileSync)(indexFile, indexImports, { flag: "w" });
+        });
+    });
+}
+exports.generateFiles = generateFiles;
+function main(url, entitiesPath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        console.log("Generating Entities");
+        const data = yield (0, fetch_schema_1.fetchSchema)(url);
+        const filteredPaths = (0, remove_non_model_paths_1.removeNonModelPaths)(data.paths);
+        yield generateFolders(entitiesPath, filteredPaths);
+        yield generateFiles(entitiesPath, filteredPaths);
+    });
+}
+exports.main = main;
+if (require.main === module) {
+    const args = process.argv.slice(2);
+    const url = args[0];
+    const entitiesPath = args[1];
+    main(url, entitiesPath);
+}

package/dist/schema-fetch.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/schema-fetch.js

@@ -0,0 +1,81 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = require("fs");
+const path_1 = require("path");
+const axios_1 = __importDefault(require("axios"));
+function fetchSchema(url, schemaPath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const response = yield axios_1.default.get(url);
+        (0, fs_1.writeFileSync)(schemaPath, JSON.stringify(response.data, null, 2));
+        return response.data;
+    });
+}
+function generateFiles(basePath, components) {
+    return __awaiter(this, void 0, void 0, function* () {
+        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 = (0, path_1.join)(basePath, "api-schema");
+            const fileName = `${schemaFolderPath}/${schemaKey}.json`;
+            (0, fs_1.writeFileSync)(fileName, JSON.stringify(schema, null, 2));
+        });
+    });
+}
+function replaceReferences(basePath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const schemaFolderPath = (0, path_1.join)(basePath, "api-schema");
+        const schemaFiles = (0, fs_1.readdirSync)(schemaFolderPath);
+        schemaFiles.forEach((file) => {
+            const filePath = (0, path_1.join)(schemaFolderPath, file);
+            const fileContent = JSON.parse((0, fs_1.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);
+            (0, fs_1.writeFileSync)(filePath, JSON.stringify(writeSchema, null, 2));
+        });
+    });
+}
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        console.log("Fetching Schema");
+        const args = process.argv.slice(2);
+        const url = args[0];
+        const basePath = args[1];
+        const schemaPath = (0, path_1.join)(basePath, "schema.json");
+        const { components } = yield fetchSchema(url, schemaPath);
+        yield generateFiles(basePath, components);
+        yield replaceReferences(basePath);
+    });
+}
+main();

package/dist/schema-full.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/schema-full.js

@@ -0,0 +1,45 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = require("fs");
+const path_1 = require("path");
+const $RefParser = require("@apidevtools/json-schema-ref-parser");
+function generateDereferencedSchema(schemaPath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const schemaContent = (0, fs_1.readFileSync)(schemaPath, "utf8");
+            const schemaObject = JSON.parse(schemaContent);
+            const dereferencedSchema = yield $RefParser.dereference(schemaObject);
+            return JSON.stringify(dereferencedSchema, null, 2);
+        }
+        catch (error) {
+            return "";
+        }
+    });
+}
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        console.log("Resolving Schemas");
+        const args = process.argv.slice(2);
+        const basePath = args[0];
+        const schemaFolderPath = (0, path_1.join)(basePath, "api-schema");
+        const outputFolder = (0, path_1.join)(basePath, "form-schema");
+        const schemaFiles = (0, fs_1.readdirSync)(schemaFolderPath);
+        let compilePromises = schemaFiles.map((schemaFile) => __awaiter(this, void 0, void 0, function* () {
+            const schemaFilePath = (0, path_1.join)(schemaFolderPath, schemaFile);
+            const generatedCode = yield generateDereferencedSchema(schemaFilePath);
+            const outputFilePath = (0, path_1.join)(outputFolder, schemaFile);
+            (0, fs_1.writeFileSync)(outputFilePath, generatedCode);
+        }));
+        let results = yield Promise.all(compilePromises);
+    });
+}
+main();

package/dist/schema-index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/schema-index.js

@@ -0,0 +1,34 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const fs_1 = require("fs");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        console.log("Generating Schema Index");
+        const args = process.argv.slice(2);
+        const basePath = args[0];
+        const schemaFolderPath = (0, path_1.join)(basePath, "form-schema");
+        let indexFileData = 'export * from "./interface";\nexport * from "./params";\n';
+        const schemaFiles = (0, fs_1.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 = yield Promise.all(compilePromises);
+        indexFileData = indexFileData + results.join("\n");
+        const outputFile = (0, path_1.join)(basePath, "index.ts");
+        (0, fs_1.writeFileSync)(outputFile, indexFileData);
+    });
+}
+main();

package/dist/schema-params.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/schema-params.js

@@ -0,0 +1,100 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = require("fs");
+const path_1 = require("path");
+const fetch_schema_1 = require("./schema/fetch-schema");
+function generateParams(paths) {
+    const pathParam = [];
+    Object.keys(paths).map((path) => {
+        const pathItem = paths[path];
+        console.log(path);
+        Object.keys(pathItem).forEach((method) => {
+            // @ts-ignore
+            const pathOperation = pathItem[method];
+            const pathParamData = [];
+            if (pathOperation.parameters) {
+                pathOperation.parameters.forEach((param) => {
+                    // @ts-ignore
+                    const paramObject = 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, schemaPath) {
+    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) => `"${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 = (0, path_1.join)(schemaPath, `params.ts`);
+    (0, fs_1.writeFileSync)(interfaceFile, interfaceFileValuesString, { flag: "w" });
+}
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        console.log("Generating Schema Parameter Definitions");
+        const args = process.argv.slice(2);
+        const url = args[0];
+        const schemaPath = args[1];
+        const data = yield (0, fetch_schema_1.fetchSchema)(url);
+        const paths = data.paths;
+        const pathParams = generateParams(paths);
+        generateInterfacesFiles(pathParams, schemaPath);
+    });
+}
+main();

package/dist/seed.d.ts

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+/**
+ * rad seed
+ *
+ * Loads CSV files from a local directory or GCS bucket into the target
+ * Iceberg namespace. Performs schema inference, PII check, and idempotent
+ * table creation before writing rows.
+ *
+ * Usage:
+ *   rad seed [--env dev|staging] [--source gs://bucket/ | --source ./myapp-dev/]
+ *
+ * Environment variables (set via CI secrets or .env):
+ *   GCP_PROJECT             GCP project ID
+ *   ICEBERG_WAREHOUSE       gs://... path to Iceberg warehouse root
+ *   ICEBERG_CATALOG_URI     sqlite:///... or http://... catalog URI
+ */
+export {};