prisma-swagger-autogen 1.0.10 → 1.0.11

package/dist/cli.cjs

@@ -28,18 +28,18 @@ var import_node_fs = __toESM(require("fs"), 1);
 var import_node_path = __toESM(require("path"), 1);
 var import_node_module = require("module");
 var import_glob = require("glob");
-var CONFIG = {
+var DEFAULT_CONFIG = {
   projectRoot: process.cwd(),
-  controllersGlob: "./src/web/api/controllers/**/*.ts",
+  controllersGlob: "./**/controllers/**/*.ts",
   outFile: "./swagger.config.js",
-  openapiOut: "./src/web/api/openapi.json",
-  serviceTitle: "Prescription Service",
-  serverUrl: "http://localhost:3008",
+  openapiOut: "./**/openapi.json",
+  serviceTitle: "Microservice Swagger Docs",
+  serverUrl: "http://localhost:3000",
   securitySchemeName: "keycloakOAuth",
   oauth: {
-    tokenUrl: "http://auth.localhost/realms/haemo/protocol/openid-connect/token",
-    refreshUrl: "http://auth.localhost/realms/haemo/protocol/openid-connect/refresh",
-    scopes: { openid: "openid scope" }
+    tokenUrl: "http://localhost:8080/realms/master/protocol/openid-connect/token",
+    refreshUrl: "http://localhost:8080/realms/master/protocol/openid-connect/refresh",
+    scopes: { openid: "openid" }
   },
   omitFieldsInWriteDtos: /* @__PURE__ */ new Set(["id", "createdAt", "updatedAt", "v"])
 };
@@ -53,6 +53,116 @@ function pluralize(name) {
 function getRequire() {
   return (0, import_node_module.createRequire)(typeof __filename !== "undefined" ? __filename : process.cwd() + "/");
 }
+function parseJsonObject(value, flagName) {
+  try {
+    const parsed = JSON.parse(value);
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new Error("must be a JSON object");
+    }
+    return parsed;
+  } catch (e) {
+    throw new Error(`Invalid JSON for ${flagName}: ${e?.message ?? String(e)}`);
+  }
+}
+function parseCsv(value) {
+  return value.split(",").map((s) => s.trim()).filter(Boolean);
+}
+function readFlagValue(args, flag) {
+  const i = args.findIndex((a) => a === flag);
+  if (i < 0) return void 0;
+  const v = args[i + 1];
+  if (!v || v.startsWith("--")) return void 0;
+  return v;
+}
+function hasFlag(args, flag) {
+  return args.includes(flag);
+}
+function parseArgs(args) {
+  if (hasFlag(args, "--help") || hasFlag(args, "-h")) {
+    const help = `
+prisma-swagger-autogen
+
+Usage:
+  prisma-swagger-autogen [options]
+
+Options:
+  --schema <path>                 Prisma schema path (default: ./prisma/schema.prisma)
+
+  --projectRoot <path>            Project root for resolving outFile/openapiOut (default: cwd)
+  --controllersGlob <glob>        Glob for controller files (default: ./**/controllers/**/*.ts)
+  --outFile <path>                Path to write swagger.config.js (default: ./swagger.config.js)
+  --openapiOut <path>             Path swagger-autogen writes OpenAPI JSON (default: ./openapi.json)
+
+  --serviceTitle <string>         OpenAPI title
+  --serverUrl <url>               OpenAPI server url
+  --securitySchemeName <string>   Security scheme name
+
+  --oauthTokenUrl <url>           OAuth2 tokenUrl
+  --oauthRefreshUrl <url>         OAuth2 refreshUrl
+  --oauthScopes <json>            OAuth2 scopes as JSON object, e.g. {"openid":"openid scope"}
+
+  --omitFields <csv>              Comma-separated fields to omit in write DTOs (default: id,createdAt,updatedAt,v)
+
+Examples:
+  prisma-swagger-autogen
+  prisma-swagger-autogen --schema ./prisma/schema.prisma
+  prisma-swagger-autogen --controllersGlob "./src/api/**/*.ts" --outFile ./swagger.config.js
+  prisma-swagger-autogen --oauthScopes '{"openid":"openid scope","profile":"profile"}'
+`.trim();
+    process.stdout.write(help + "\n");
+    process.exit(0);
+  }
+  const schemaPath = readFlagValue(args, "--schema");
+  const projectRoot = readFlagValue(args, "--projectRoot");
+  const controllersGlob = readFlagValue(args, "--controllersGlob");
+  const outFile = readFlagValue(args, "--outFile");
+  const openapiOut = readFlagValue(args, "--openapiOut");
+  const serviceTitle = readFlagValue(args, "--serviceTitle");
+  const serverUrl = readFlagValue(args, "--serverUrl");
+  const securitySchemeName = readFlagValue(args, "--securitySchemeName");
+  const oauthTokenUrl = readFlagValue(args, "--oauthTokenUrl");
+  const oauthRefreshUrl = readFlagValue(args, "--oauthRefreshUrl");
+  const oauthScopesRaw = readFlagValue(args, "--oauthScopes");
+  const omitFieldsRaw = readFlagValue(args, "--omitFields");
+  const oauthScopes = oauthScopesRaw ? parseJsonObject(oauthScopesRaw, "--oauthScopes") : void 0;
+  const omitFieldsInWriteDtos = omitFieldsRaw ? parseCsv(omitFieldsRaw) : void 0;
+  return {
+    schemaPath,
+    projectRoot,
+    controllersGlob,
+    outFile,
+    openapiOut,
+    serviceTitle,
+    serverUrl,
+    securitySchemeName,
+    oauthTokenUrl,
+    oauthRefreshUrl,
+    oauthScopes,
+    omitFieldsInWriteDtos
+  };
+}
+function mergeConfig(base, parsed) {
+  const cfg = {
+    ...base,
+    projectRoot: parsed.projectRoot ? import_node_path.default.resolve(process.cwd(), parsed.projectRoot) : base.projectRoot,
+    controllersGlob: parsed.controllersGlob ?? base.controllersGlob,
+    outFile: parsed.outFile ?? base.outFile,
+    openapiOut: parsed.openapiOut ?? base.openapiOut,
+    serviceTitle: parsed.serviceTitle ?? base.serviceTitle,
+    serverUrl: parsed.serverUrl ?? base.serverUrl,
+    securitySchemeName: parsed.securitySchemeName ?? base.securitySchemeName,
+    oauth: {
+      tokenUrl: parsed.oauthTokenUrl ?? base.oauth.tokenUrl,
+      refreshUrl: parsed.oauthRefreshUrl ?? base.oauth.refreshUrl,
+      scopes: parsed.oauthScopes ?? base.oauth.scopes
+    },
+    omitFieldsInWriteDtos: parsed.omitFieldsInWriteDtos ? new Set(parsed.omitFieldsInWriteDtos) : base.omitFieldsInWriteDtos
+  };
+  cfg.controllersGlob = ensurePosix(cfg.controllersGlob);
+  cfg.outFile = ensurePosix(cfg.outFile);
+  cfg.openapiOut = ensurePosix(cfg.openapiOut);
+  return cfg;
+}
 async function loadDmmfFromProject(schemaPath) {
   const resolvedSchemaPath = schemaPath ? import_node_path.default.resolve(process.cwd(), schemaPath) : import_node_path.default.resolve(process.cwd(), "prisma/schema.prisma");
   if (!import_node_fs.default.existsSync(resolvedSchemaPath)) {
@@ -156,7 +266,7 @@ function listResponseSchema(itemRef) {
     required: ["count", "hasPreviousPage", "hasNextPage", "pageNumber", "pageSize", "totalPages", "items"]
   };
 }
-async function buildSchemasFromPrismaDmmf(schemaPath) {
+async function buildSchemasFromPrismaDmmf(cfg, schemaPath) {
   const dmmf = await loadDmmfFromProject(schemaPath);
   const schemas = {};
   const getRefName = (modelName) => `Get${modelName}Response`;
@@ -169,7 +279,7 @@ async function buildSchemasFromPrismaDmmf(schemaPath) {
     const putName = `Put${model.name}Request`;
     const listName = `List${pluralize(model.name)}Response`;
     const getSchema = modelToGetSchema(model, getRefName);
-    const postSchema = stripWriteFields(model, getSchema, CONFIG.omitFieldsInWriteDtos);
+    const postSchema = stripWriteFields(model, getSchema, cfg.omitFieldsInWriteDtos);
     const putSchema = makeAllOptional(postSchema);
     schemas[getName] = getSchema;
     schemas[postName] = postSchema;
@@ -178,40 +288,41 @@ async function buildSchemasFromPrismaDmmf(schemaPath) {
   }
   return schemas;
 }
-function generateSwaggerConfigJs(schemas) {
-  const routes = (0, import_glob.globSync)(CONFIG.controllersGlob, { nodir: true }).map((p) => ensurePosix(p));
+function generateSwaggerConfigJs(cfg, schemas) {
+  const routes = (0, import_glob.globSync)(cfg.controllersGlob, { nodir: true }).map((p) => ensurePosix(p));
   const docs = {
-    info: { title: CONFIG.serviceTitle },
-    servers: [{ url: CONFIG.serverUrl }],
+    info: { title: cfg.serviceTitle },
+    servers: [{ url: cfg.serverUrl }],
     components: {
       schemas,
       securitySchemes: {
-        [CONFIG.securitySchemeName]: {
+        [cfg.securitySchemeName]: {
           type: "oauth2",
           description: "This API uses OAuth2 with the password flow.",
           flows: {
             password: {
-              tokenUrl: CONFIG.oauth.tokenUrl,
-              refreshUrl: CONFIG.oauth.refreshUrl,
-              scopes: CONFIG.oauth.scopes
+              tokenUrl: cfg.oauth.tokenUrl,
+              refreshUrl: cfg.oauth.refreshUrl,
+              scopes: cfg.oauth.scopes
             }
           }
         }
       }
     },
-    security: [{ [CONFIG.securitySchemeName]: ["openid"] }]
+    security: [{ [cfg.securitySchemeName]: ["openid"] }]
   };
   const fileContent = `const swaggerAutogen = require('swagger-autogen')();
 const docs = ${JSON.stringify(docs, null, 2)};
 const routes = ${JSON.stringify(routes, null, 2)};
-swaggerAutogen('${ensurePosix(CONFIG.openapiOut)}', routes, docs);`;
-  import_node_fs.default.writeFileSync(import_node_path.default.resolve(CONFIG.projectRoot, CONFIG.outFile), fileContent, "utf8");
+swaggerAutogen('${ensurePosix(cfg.openapiOut)}', routes, docs);`;
+  const outPath = import_node_path.default.resolve(cfg.projectRoot, cfg.outFile);
+  import_node_fs.default.writeFileSync(outPath, fileContent, "utf8");
 }
 async function run(args = []) {
-  const schemaFlagIndex = args.findIndex((a) => a === "--schema");
-  const schemaPath = schemaFlagIndex >= 0 ? args[schemaFlagIndex + 1] : void 0;
-  const schemas = await buildSchemasFromPrismaDmmf(schemaPath);
-  generateSwaggerConfigJs(schemas);
+  const parsed = parseArgs(args);
+  const cfg = mergeConfig(DEFAULT_CONFIG, parsed);
+  const schemas = await buildSchemasFromPrismaDmmf(cfg, parsed.schemaPath);
+  generateSwaggerConfigJs(cfg, schemas);
 }
 
 // src/cli.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prisma-swagger-autogen",
-  "version": "1.0.10",
+  "version": "1.0.11",
   "description": "Generate swagger-autogen config + Prisma DMMF schemas and fix swagger-autogen output.",
   "license": "MIT",
   "author": "Joyce Marvin Rafflenbeul",