prisma-swagger-autogen 1.0.4 → 1.0.6

package/dist/bin.cjs

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require('./cli.cjs');

package/dist/chunk-LHCOAEWQ.cjs

@@ -0,0 +1,193 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }// src/index.ts
+var _fs = require('fs'); var _fs2 = _interopRequireDefault(_fs);
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+var _module = require('module');
+var _glob = require('glob');
+var CONFIG = {
+  projectRoot: process.cwd(),
+  controllersGlob: "./src/web/api/controllers/**/*.ts",
+  outFile: "./swagger.config.js",
+  openapiOut: "./src/web/api/openapi.json",
+  serviceTitle: "Prescription Service",
+  serverUrl: "http://localhost:3008",
+  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" }
+  },
+  omitFieldsInWriteDtos: /* @__PURE__ */ new Set(["id", "createdAt", "updatedAt", "v"])
+};
+function ensurePosix(p) {
+  return p.split(_path2.default.sep).join(_path2.default.posix.sep);
+}
+function pluralize(name) {
+  if (name.endsWith("s")) return `${name}es`;
+  return `${name}s`;
+}
+function getRequire() {
+  const base = typeof __filename !== "undefined" ? __filename : import.meta.url;
+  return _module.createRequire.call(void 0, base);
+}
+function loadDmmfFromProject(schemaPath) {
+  const resolvedSchemaPath = schemaPath ? _path2.default.resolve(process.cwd(), schemaPath) : _path2.default.resolve(process.cwd(), "prisma/schema.prisma");
+  if (!_fs2.default.existsSync(resolvedSchemaPath)) {
+    throw new Error(`Prisma schema not found at ${resolvedSchemaPath}`);
+  }
+  const datamodel = _fs2.default.readFileSync(resolvedSchemaPath, "utf8");
+  const require2 = getRequire();
+  const internals = require2("@prisma/internals");
+  if (typeof internals.getDMMF !== "function") {
+    throw new Error(`@prisma/internals.getDMMF not available`);
+  }
+  return internals.getDMMF({ datamodel });
+}
+function scalarToSchema(scalar) {
+  switch (scalar) {
+    case "String":
+      return { type: "string" };
+    case "Boolean":
+      return { type: "boolean" };
+    case "Int":
+      return { type: "integer" };
+    case "BigInt":
+      return { type: "integer", format: "int64" };
+    case "Float":
+      return { type: "number" };
+    case "Decimal":
+      return { type: "number" };
+    case "DateTime":
+      return { type: "string", format: "date-time" };
+    case "Json":
+      return { type: "object" };
+    case "Bytes":
+      return { type: "string", format: "byte" };
+    default:
+      return { type: "string" };
+  }
+}
+function fieldSchema(field, getRefName) {
+  if (field.kind === "scalar") {
+    const base = scalarToSchema(field.type);
+    if (field.isList) return { type: "array", items: base };
+    return base;
+  }
+  if (field.kind === "enum") {
+    const base = { $ref: `#/components/schemas/${field.type}` };
+    if (field.isList) return { type: "array", items: base };
+    return base;
+  }
+  if (field.kind === "object") {
+    const ref = { $ref: `#/components/schemas/${getRefName(String(field.type))}` };
+    if (field.isList) return { type: "array", items: ref };
+    return ref;
+  }
+  return { type: "object" };
+}
+function modelToGetSchema(model, getRefName) {
+  const properties = {};
+  const required = [];
+  for (const f of model.fields) {
+    properties[f.name] = fieldSchema(f, getRefName);
+    if (f.isRequired) required.push(f.name);
+  }
+  const schema = { type: "object", properties };
+  if (required.length) schema.required = required;
+  return schema;
+}
+function stripWriteFields(model, getSchema, omit) {
+  const schema = JSON.parse(JSON.stringify(getSchema));
+  if (!schema.properties) return schema;
+  const relationFieldNames = new Set(model.fields.filter((f) => f.kind === "object").map((f) => f.name));
+  for (const key of Object.keys(schema.properties)) {
+    if (omit.has(key) || relationFieldNames.has(key)) {
+      delete schema.properties[key];
+    }
+  }
+  if (Array.isArray(schema.required)) {
+    schema.required = schema.required.filter((k) => !omit.has(k) && !relationFieldNames.has(k));
+    if (schema.required.length === 0) delete schema.required;
+  }
+  return schema;
+}
+function makeAllOptional(schema) {
+  const s = JSON.parse(JSON.stringify(schema));
+  delete s.required;
+  return s;
+}
+function listResponseSchema(itemRef) {
+  return {
+    type: "object",
+    properties: {
+      count: { type: "number" },
+      hasPreviousPage: { type: "boolean" },
+      hasNextPage: { type: "boolean" },
+      pageNumber: { type: "number" },
+      pageSize: { type: "number" },
+      totalPages: { type: "number" },
+      items: { type: "array", items: { $ref: itemRef } }
+    },
+    required: ["count", "hasPreviousPage", "hasNextPage", "pageNumber", "pageSize", "totalPages", "items"]
+  };
+}
+function buildSchemasFromPrismaDmmf(schemaPath) {
+  const dmmf = loadDmmfFromProject(schemaPath);
+  const schemas = {};
+  const getRefName = (modelName) => `Get${modelName}Response`;
+  for (const e of dmmf.datamodel.enums) {
+    schemas[e.name] = { type: "string", enum: e.values.map((v) => v.name) };
+  }
+  for (const model of dmmf.datamodel.models) {
+    const getName = `Get${model.name}Response`;
+    const postName = `Post${model.name}Request`;
+    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 putSchema = makeAllOptional(postSchema);
+    schemas[getName] = getSchema;
+    schemas[postName] = postSchema;
+    schemas[putName] = putSchema;
+    schemas[listName] = listResponseSchema(`#/components/schemas/${getName}`);
+  }
+  return schemas;
+}
+function generateSwaggerConfigJs(schemas) {
+  const routes = _glob.globSync.call(void 0, CONFIG.controllersGlob, { nodir: true }).map((p) => ensurePosix(p));
+  const docs = {
+    info: { title: CONFIG.serviceTitle },
+    servers: [{ url: CONFIG.serverUrl }],
+    components: {
+      schemas,
+      securitySchemes: {
+        [CONFIG.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
+            }
+          }
+        }
+      }
+    },
+    security: [{ [CONFIG.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);`;
+  _fs2.default.writeFileSync(_path2.default.resolve(CONFIG.projectRoot, CONFIG.outFile), fileContent, "utf8");
+}
+async function run(args = []) {
+  const schemaFlagIndex = args.findIndex((a) => a === "--schema");
+  const schemaPath = schemaFlagIndex >= 0 ? args[schemaFlagIndex + 1] : void 0;
+  const schemas = buildSchemasFromPrismaDmmf(schemaPath);
+  generateSwaggerConfigJs(schemas);
+}
+
+
+
+exports.run = run;

package/dist/cli.cjs

@@ -1,3 +1,4 @@
+#!/usr/bin/env node
 "use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;

package/dist/cli.js

@@ -1,6 +1,194 @@
-import {
-  run
-} from "./chunk-NLFDSHIX.js";
+#!/usr/bin/env node
+
+// src/index.ts
+import fs from "fs";
+import path from "path";
+import { createRequire } from "module";
+import { globSync } from "glob";
+var CONFIG = {
+  projectRoot: process.cwd(),
+  controllersGlob: "./src/web/api/controllers/**/*.ts",
+  outFile: "./swagger.config.js",
+  openapiOut: "./src/web/api/openapi.json",
+  serviceTitle: "Prescription Service",
+  serverUrl: "http://localhost:3008",
+  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" }
+  },
+  omitFieldsInWriteDtos: /* @__PURE__ */ new Set(["id", "createdAt", "updatedAt", "v"])
+};
+function ensurePosix(p) {
+  return p.split(path.sep).join(path.posix.sep);
+}
+function pluralize(name) {
+  if (name.endsWith("s")) return `${name}es`;
+  return `${name}s`;
+}
+function getRequire() {
+  const base = typeof __filename !== "undefined" ? __filename : import.meta.url;
+  return createRequire(base);
+}
+function loadDmmfFromProject(schemaPath) {
+  const resolvedSchemaPath = schemaPath ? path.resolve(process.cwd(), schemaPath) : path.resolve(process.cwd(), "prisma/schema.prisma");
+  if (!fs.existsSync(resolvedSchemaPath)) {
+    throw new Error(`Prisma schema not found at ${resolvedSchemaPath}`);
+  }
+  const datamodel = fs.readFileSync(resolvedSchemaPath, "utf8");
+  const require2 = getRequire();
+  const internals = require2("@prisma/internals");
+  if (typeof internals.getDMMF !== "function") {
+    throw new Error(`@prisma/internals.getDMMF not available`);
+  }
+  return internals.getDMMF({ datamodel });
+}
+function scalarToSchema(scalar) {
+  switch (scalar) {
+    case "String":
+      return { type: "string" };
+    case "Boolean":
+      return { type: "boolean" };
+    case "Int":
+      return { type: "integer" };
+    case "BigInt":
+      return { type: "integer", format: "int64" };
+    case "Float":
+      return { type: "number" };
+    case "Decimal":
+      return { type: "number" };
+    case "DateTime":
+      return { type: "string", format: "date-time" };
+    case "Json":
+      return { type: "object" };
+    case "Bytes":
+      return { type: "string", format: "byte" };
+    default:
+      return { type: "string" };
+  }
+}
+function fieldSchema(field, getRefName) {
+  if (field.kind === "scalar") {
+    const base = scalarToSchema(field.type);
+    if (field.isList) return { type: "array", items: base };
+    return base;
+  }
+  if (field.kind === "enum") {
+    const base = { $ref: `#/components/schemas/${field.type}` };
+    if (field.isList) return { type: "array", items: base };
+    return base;
+  }
+  if (field.kind === "object") {
+    const ref = { $ref: `#/components/schemas/${getRefName(String(field.type))}` };
+    if (field.isList) return { type: "array", items: ref };
+    return ref;
+  }
+  return { type: "object" };
+}
+function modelToGetSchema(model, getRefName) {
+  const properties = {};
+  const required = [];
+  for (const f of model.fields) {
+    properties[f.name] = fieldSchema(f, getRefName);
+    if (f.isRequired) required.push(f.name);
+  }
+  const schema = { type: "object", properties };
+  if (required.length) schema.required = required;
+  return schema;
+}
+function stripWriteFields(model, getSchema, omit) {
+  const schema = JSON.parse(JSON.stringify(getSchema));
+  if (!schema.properties) return schema;
+  const relationFieldNames = new Set(model.fields.filter((f) => f.kind === "object").map((f) => f.name));
+  for (const key of Object.keys(schema.properties)) {
+    if (omit.has(key) || relationFieldNames.has(key)) {
+      delete schema.properties[key];
+    }
+  }
+  if (Array.isArray(schema.required)) {
+    schema.required = schema.required.filter((k) => !omit.has(k) && !relationFieldNames.has(k));
+    if (schema.required.length === 0) delete schema.required;
+  }
+  return schema;
+}
+function makeAllOptional(schema) {
+  const s = JSON.parse(JSON.stringify(schema));
+  delete s.required;
+  return s;
+}
+function listResponseSchema(itemRef) {
+  return {
+    type: "object",
+    properties: {
+      count: { type: "number" },
+      hasPreviousPage: { type: "boolean" },
+      hasNextPage: { type: "boolean" },
+      pageNumber: { type: "number" },
+      pageSize: { type: "number" },
+      totalPages: { type: "number" },
+      items: { type: "array", items: { $ref: itemRef } }
+    },
+    required: ["count", "hasPreviousPage", "hasNextPage", "pageNumber", "pageSize", "totalPages", "items"]
+  };
+}
+function buildSchemasFromPrismaDmmf(schemaPath) {
+  const dmmf = loadDmmfFromProject(schemaPath);
+  const schemas = {};
+  const getRefName = (modelName) => `Get${modelName}Response`;
+  for (const e of dmmf.datamodel.enums) {
+    schemas[e.name] = { type: "string", enum: e.values.map((v) => v.name) };
+  }
+  for (const model of dmmf.datamodel.models) {
+    const getName = `Get${model.name}Response`;
+    const postName = `Post${model.name}Request`;
+    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 putSchema = makeAllOptional(postSchema);
+    schemas[getName] = getSchema;
+    schemas[postName] = postSchema;
+    schemas[putName] = putSchema;
+    schemas[listName] = listResponseSchema(`#/components/schemas/${getName}`);
+  }
+  return schemas;
+}
+function generateSwaggerConfigJs(schemas) {
+  const routes = globSync(CONFIG.controllersGlob, { nodir: true }).map((p) => ensurePosix(p));
+  const docs = {
+    info: { title: CONFIG.serviceTitle },
+    servers: [{ url: CONFIG.serverUrl }],
+    components: {
+      schemas,
+      securitySchemes: {
+        [CONFIG.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
+            }
+          }
+        }
+      }
+    },
+    security: [{ [CONFIG.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);`;
+  fs.writeFileSync(path.resolve(CONFIG.projectRoot, CONFIG.outFile), fileContent, "utf8");
+}
+async function run(args = []) {
+  const schemaFlagIndex = args.findIndex((a) => a === "--schema");
+  const schemaPath = schemaFlagIndex >= 0 ? args[schemaFlagIndex + 1] : void 0;
+  const schemas = buildSchemasFromPrismaDmmf(schemaPath);
+  generateSwaggerConfigJs(schemas);
+}
 
 // src/cli.ts
 void run(process.argv.slice(2)).catch((e) => {

package/dist/index.cjs

@@ -1,3 +1,4 @@
+#!/usr/bin/env node
 "use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;

package/dist/index.js

@@ -1,6 +1,194 @@
-import {
-  run
-} from "./chunk-NLFDSHIX.js";
+#!/usr/bin/env node
+
+// src/index.ts
+import fs from "fs";
+import path from "path";
+import { createRequire } from "module";
+import { globSync } from "glob";
+var CONFIG = {
+  projectRoot: process.cwd(),
+  controllersGlob: "./src/web/api/controllers/**/*.ts",
+  outFile: "./swagger.config.js",
+  openapiOut: "./src/web/api/openapi.json",
+  serviceTitle: "Prescription Service",
+  serverUrl: "http://localhost:3008",
+  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" }
+  },
+  omitFieldsInWriteDtos: /* @__PURE__ */ new Set(["id", "createdAt", "updatedAt", "v"])
+};
+function ensurePosix(p) {
+  return p.split(path.sep).join(path.posix.sep);
+}
+function pluralize(name) {
+  if (name.endsWith("s")) return `${name}es`;
+  return `${name}s`;
+}
+function getRequire() {
+  const base = typeof __filename !== "undefined" ? __filename : import.meta.url;
+  return createRequire(base);
+}
+function loadDmmfFromProject(schemaPath) {
+  const resolvedSchemaPath = schemaPath ? path.resolve(process.cwd(), schemaPath) : path.resolve(process.cwd(), "prisma/schema.prisma");
+  if (!fs.existsSync(resolvedSchemaPath)) {
+    throw new Error(`Prisma schema not found at ${resolvedSchemaPath}`);
+  }
+  const datamodel = fs.readFileSync(resolvedSchemaPath, "utf8");
+  const require2 = getRequire();
+  const internals = require2("@prisma/internals");
+  if (typeof internals.getDMMF !== "function") {
+    throw new Error(`@prisma/internals.getDMMF not available`);
+  }
+  return internals.getDMMF({ datamodel });
+}
+function scalarToSchema(scalar) {
+  switch (scalar) {
+    case "String":
+      return { type: "string" };
+    case "Boolean":
+      return { type: "boolean" };
+    case "Int":
+      return { type: "integer" };
+    case "BigInt":
+      return { type: "integer", format: "int64" };
+    case "Float":
+      return { type: "number" };
+    case "Decimal":
+      return { type: "number" };
+    case "DateTime":
+      return { type: "string", format: "date-time" };
+    case "Json":
+      return { type: "object" };
+    case "Bytes":
+      return { type: "string", format: "byte" };
+    default:
+      return { type: "string" };
+  }
+}
+function fieldSchema(field, getRefName) {
+  if (field.kind === "scalar") {
+    const base = scalarToSchema(field.type);
+    if (field.isList) return { type: "array", items: base };
+    return base;
+  }
+  if (field.kind === "enum") {
+    const base = { $ref: `#/components/schemas/${field.type}` };
+    if (field.isList) return { type: "array", items: base };
+    return base;
+  }
+  if (field.kind === "object") {
+    const ref = { $ref: `#/components/schemas/${getRefName(String(field.type))}` };
+    if (field.isList) return { type: "array", items: ref };
+    return ref;
+  }
+  return { type: "object" };
+}
+function modelToGetSchema(model, getRefName) {
+  const properties = {};
+  const required = [];
+  for (const f of model.fields) {
+    properties[f.name] = fieldSchema(f, getRefName);
+    if (f.isRequired) required.push(f.name);
+  }
+  const schema = { type: "object", properties };
+  if (required.length) schema.required = required;
+  return schema;
+}
+function stripWriteFields(model, getSchema, omit) {
+  const schema = JSON.parse(JSON.stringify(getSchema));
+  if (!schema.properties) return schema;
+  const relationFieldNames = new Set(model.fields.filter((f) => f.kind === "object").map((f) => f.name));
+  for (const key of Object.keys(schema.properties)) {
+    if (omit.has(key) || relationFieldNames.has(key)) {
+      delete schema.properties[key];
+    }
+  }
+  if (Array.isArray(schema.required)) {
+    schema.required = schema.required.filter((k) => !omit.has(k) && !relationFieldNames.has(k));
+    if (schema.required.length === 0) delete schema.required;
+  }
+  return schema;
+}
+function makeAllOptional(schema) {
+  const s = JSON.parse(JSON.stringify(schema));
+  delete s.required;
+  return s;
+}
+function listResponseSchema(itemRef) {
+  return {
+    type: "object",
+    properties: {
+      count: { type: "number" },
+      hasPreviousPage: { type: "boolean" },
+      hasNextPage: { type: "boolean" },
+      pageNumber: { type: "number" },
+      pageSize: { type: "number" },
+      totalPages: { type: "number" },
+      items: { type: "array", items: { $ref: itemRef } }
+    },
+    required: ["count", "hasPreviousPage", "hasNextPage", "pageNumber", "pageSize", "totalPages", "items"]
+  };
+}
+function buildSchemasFromPrismaDmmf(schemaPath) {
+  const dmmf = loadDmmfFromProject(schemaPath);
+  const schemas = {};
+  const getRefName = (modelName) => `Get${modelName}Response`;
+  for (const e of dmmf.datamodel.enums) {
+    schemas[e.name] = { type: "string", enum: e.values.map((v) => v.name) };
+  }
+  for (const model of dmmf.datamodel.models) {
+    const getName = `Get${model.name}Response`;
+    const postName = `Post${model.name}Request`;
+    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 putSchema = makeAllOptional(postSchema);
+    schemas[getName] = getSchema;
+    schemas[postName] = postSchema;
+    schemas[putName] = putSchema;
+    schemas[listName] = listResponseSchema(`#/components/schemas/${getName}`);
+  }
+  return schemas;
+}
+function generateSwaggerConfigJs(schemas) {
+  const routes = globSync(CONFIG.controllersGlob, { nodir: true }).map((p) => ensurePosix(p));
+  const docs = {
+    info: { title: CONFIG.serviceTitle },
+    servers: [{ url: CONFIG.serverUrl }],
+    components: {
+      schemas,
+      securitySchemes: {
+        [CONFIG.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
+            }
+          }
+        }
+      }
+    },
+    security: [{ [CONFIG.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);`;
+  fs.writeFileSync(path.resolve(CONFIG.projectRoot, CONFIG.outFile), fileContent, "utf8");
+}
+async function run(args = []) {
+  const schemaFlagIndex = args.findIndex((a) => a === "--schema");
+  const schemaPath = schemaFlagIndex >= 0 ? args[schemaFlagIndex + 1] : void 0;
+  const schemas = buildSchemasFromPrismaDmmf(schemaPath);
+  generateSwaggerConfigJs(schemas);
+}
 export {
   run
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prisma-swagger-autogen",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "Generate swagger-autogen config + Prisma DMMF schemas and fix swagger-autogen output.",
   "license": "MIT",
   "author": "Joyce Marvin Rafflenbeul",
@@ -31,7 +31,7 @@
     }
   },
   "bin": {
-    "prisma-swagger-autogen": "./dist/cli.cjs"
+    "prisma-swagger-autogen": "dist/bin.cjs"
   },
   "files": [
     "dist",
@@ -39,20 +39,20 @@
     "LICENSE"
   ],
   "scripts": {
-    "build": "tsup src/index.ts src/cli.ts --format esm,cjs --dts --out-dir dist --tsconfig tsconfig.json",
+    "build": "tsup src/index.ts src/cli.ts --format esm,cjs --dts --out-dir dist --tsconfig tsconfig.json && node scripts/make-bin.cjs && chmod +x dist/bin.cjs",
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@prisma/internals": "^6.0.0"
+    "@prisma/internals": "^6.0.0",
+    "glob": "^10.3.10"
   },
   "peerDependencies": {
     "@prisma/client": ">=4",
-    "glob": ">=10",
     "swagger-autogen": ">=2"
   },
   "devDependencies": {
     "@types/node": "^25.1.0",
-    "tsup": "^8.0.0",
+    "tsup": "^8.5.1",
     "typescript": "^5.0.0"
   }
 }