tina4-nodejs 3.13.83 → 3.13.85

package/packages/swagger/dist/index.js

@@ -0,0 +1,445 @@
+// src/generator.ts
+var WRITE_METHODS = /* @__PURE__ */ new Set(["post", "put", "patch", "delete"]);
+var registeredSchemes = {};
+var registeredSchemas = {};
+function addSecurityScheme(name, definition) {
+  registeredSchemes[name] = definition;
+}
+function addSchema(name, schema) {
+  registeredSchemas[name] = schema;
+}
+function resetRegistry() {
+  for (const k of Object.keys(registeredSchemes)) delete registeredSchemes[k];
+  for (const k of Object.keys(registeredSchemas)) delete registeredSchemas[k];
+}
+function resolveOpenApiVersion() {
+  const v = (process.env.TINA4_SWAGGER_OPENAPI ?? "").trim();
+  if (!v) return "3.0.3";
+  if (v === "3.1" || v === "3.1.0") return "3.1.0";
+  if (v === "3.0" || v === "3.0.3") return "3.0.3";
+  return v;
+}
+function csv(val) {
+  return (val ?? "").split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+}
+function resolveSecuritySchemes() {
+  const bearerFormat = process.env.TINA4_SWAGGER_BEARER_FORMAT ?? "JWT";
+  const schemes = {
+    bearerAuth: { type: "http", scheme: "bearer", bearerFormat }
+  };
+  const apiKeyName = (process.env.TINA4_SWAGGER_API_KEY_NAME ?? "").trim();
+  if (apiKeyName.length > 0) {
+    const rawIn = process.env.TINA4_SWAGGER_API_KEY_IN ?? "header";
+    const apiKeyIn = ["header", "query", "cookie"].includes(rawIn) ? rawIn : "header";
+    schemes.apiKeyAuth = { type: "apiKey", name: apiKeyName, in: apiKeyIn };
+  }
+  for (const [name, def] of Object.entries(registeredSchemes)) {
+    schemes[name] = def;
+  }
+  return schemes;
+}
+function normalizeSecurity(value, scopes) {
+  if ((value === "public" || value === "none" || value === void 0 || value === null) && (!scopes || scopes.length === 0)) {
+    return [];
+  }
+  if (typeof value === "string") {
+    return [{ [value]: [...scopes ?? []] }];
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 0) return [];
+    return value.map((req) => normalizeRequirementMap(req));
+  }
+  if (value !== null && typeof value === "object") {
+    return [normalizeRequirementMap(value)];
+  }
+  return [];
+}
+function normalizeRequirementMap(req) {
+  const out = {};
+  for (const [k, v] of Object.entries(req)) out[k] = [...v ?? []];
+  return out;
+}
+function sanitizeSecurity(reqs, schemes) {
+  const scopeOk = /* @__PURE__ */ new Set(["oauth2", "openIdConnect"]);
+  return reqs.map((req) => {
+    const clean = {};
+    for (const [name, scopes] of Object.entries(req)) {
+      const stype = schemes[name]?.type;
+      clean[name] = scopeOk.has(stype) ? [...scopes] : [];
+    }
+    return clean;
+  });
+}
+function generate(routes, models = []) {
+  const info = {
+    title: process.env.TINA4_SWAGGER_TITLE ?? "Tina4 API",
+    version: process.env.TINA4_SWAGGER_VERSION ?? "0.0.1",
+    description: process.env.TINA4_SWAGGER_DESCRIPTION ?? "Auto-generated API documentation"
+  };
+  const contactEmail = (process.env.TINA4_SWAGGER_CONTACT_EMAIL ?? "").trim();
+  const contactName = (process.env.TINA4_SWAGGER_CONTACT_TEAM ?? "").trim();
+  const contactUrl = (process.env.TINA4_SWAGGER_CONTACT_URL ?? "").trim();
+  const contact = {};
+  if (contactName.length > 0) contact.name = contactName;
+  if (contactUrl.length > 0) contact.url = contactUrl;
+  if (contactEmail.length > 0) contact.email = contactEmail;
+  if (Object.keys(contact).length > 0) info.contact = contact;
+  const licenseRaw = (process.env.TINA4_SWAGGER_LICENSE ?? "").trim();
+  if (licenseRaw.length > 0) {
+    const [name, url] = licenseRaw.split("|").map((s) => s.trim());
+    info.license = url ? { name, url } : { name };
+  }
+  const schemes = resolveSecuritySchemes();
+  const spec = {
+    openapi: resolveOpenApiVersion(),
+    info,
+    servers: resolveServers(),
+    paths: {},
+    components: {
+      schemas: {},
+      // Configurable security schemes (v3.13.42): bearerFormat via env, optional
+      // apiKey scheme, plus any programmatically-registered schemes (which may
+      // override bearerAuth — e.g. an oauth2 scheme with scopes).
+      securitySchemes: schemes
+    }
+  };
+  const defaultScheme = process.env.TINA4_SWAGGER_DEFAULT_SCHEME ?? "bearerAuth";
+  const includePrefixes = csv(process.env.TINA4_SWAGGER_INCLUDE);
+  const excludePrefixes = csv(process.env.TINA4_SWAGGER_EXCLUDE);
+  const refSchemas = /* @__PURE__ */ new Set();
+  for (const model of models) {
+    const schema = modelToSchema(model);
+    spec.components.schemas[model.tableName] = schema;
+  }
+  const usedTags = [];
+  const seenIds = /* @__PURE__ */ new Set();
+  for (const route of routes) {
+    if (!isIncludedPath(route.pattern, includePrefixes, excludePrefixes)) continue;
+    const openApiPath = patternToOpenAPI(route.pattern);
+    const method = route.method.toLowerCase();
+    if (!spec.paths[openApiPath]) {
+      spec.paths[openApiPath] = {};
+    }
+    const tags = route.meta?.tags ?? inferTags(route.pattern);
+    for (const t of tags) {
+      if (!usedTags.includes(t)) usedTags.push(t);
+    }
+    const operation = {
+      operationId: uniqueOperationId(method, openApiPath, seenIds),
+      summary: route.meta?.summary ?? `${route.method} ${route.pattern}`,
+      tags,
+      responses: route.meta?.responses ?? {
+        "200": { description: "Successful response" }
+      }
+    };
+    if (route.meta?.description) operation.description = route.meta.description;
+    if (route.meta?.deprecated) operation.deprecated = true;
+    const pathParams = extractPathParams(route.pattern);
+    if (pathParams.length > 0) {
+      operation.parameters = pathParams.map((name) => ({
+        name,
+        in: "path",
+        required: true,
+        schema: { type: "string" }
+      }));
+    }
+    if (method === "get" && !route.pattern.includes("[id]") && !route.pattern.includes("[...")) {
+      const modelName = inferModelFromPath(route.pattern);
+      if (modelName && models.some((m) => m.tableName === modelName)) {
+        operation.parameters = [
+          ...operation.parameters ?? [],
+          { name: "page", in: "query", schema: { type: "integer", default: 1 } },
+          { name: "limit", in: "query", schema: { type: "integer", default: 20 } },
+          { name: "sort", in: "query", schema: { type: "string" }, description: "Sort fields (prefix with - for descending)" }
+        ];
+      }
+    }
+    const reqSchemaRef = parseRequestSchema(route.meta?.requestSchema);
+    if (reqSchemaRef && (method === "post" || method === "put" || method === "patch")) {
+      refSchemas.add(reqSchemaRef.name);
+      const media = {
+        schema: { $ref: `#/components/schemas/${reqSchemaRef.name}` }
+      };
+      if (route.meta?.example !== void 0) media.example = route.meta.example;
+      operation.requestBody = {
+        content: { [reqSchemaRef.contentType]: media }
+      };
+    } else if (method === "post" || method === "put") {
+      const modelName = inferModelFromPath(route.pattern);
+      if (modelName && models.some((m) => m.tableName === modelName)) {
+        const media = {
+          schema: { $ref: `#/components/schemas/${modelName}` }
+        };
+        if (route.meta?.example !== void 0) media.example = route.meta.example;
+        operation.requestBody = {
+          required: true,
+          content: { "application/json": media }
+        };
+        operation.responses = {
+          ...method === "post" ? { "201": { description: "Created", content: { "application/json": { schema: { $ref: `#/components/schemas/${modelName}` } } } } } : { "200": { description: "Updated", content: { "application/json": { schema: { $ref: `#/components/schemas/${modelName}` } } } } },
+          "422": { description: "Validation failed" }
+        };
+      } else if (route.meta?.example !== void 0) {
+        operation.requestBody = {
+          content: { "application/json": { schema: inferSchema(route.meta.example), example: route.meta.example } }
+        };
+      }
+    }
+    const respSchemas = parseResponseSchemas(route.meta?.responseSchemas);
+    if (respSchemas.length > 0) {
+      const responses = operation.responses;
+      for (const { status, name, isList } of respSchemas) {
+        refSchemas.add(name);
+        const sref = `#/components/schemas/${name}`;
+        const schema = isList ? { type: "array", items: { $ref: sref } } : { $ref: sref };
+        responses[status] = {
+          description: status.startsWith("2") ? "Successful response" : "Response",
+          content: { "application/json": { schema } }
+        };
+      }
+    }
+    const hasExplicitSecurity = route.meta?.security !== void 0 || route.meta?.scopes !== void 0 && route.meta.scopes.length > 0;
+    if (hasExplicitSecurity) {
+      const normalized = normalizeSecurity(route.meta?.security, route.meta?.scopes);
+      operation.security = normalized.length > 0 ? sanitizeSecurity(normalized, schemes) : [];
+      if (normalized.length > 0) {
+        const responses = operation.responses;
+        if (!responses["401"]) responses["401"] = { description: "Unauthorized" };
+      }
+    } else if (routeRequiresAuth(route, method)) {
+      operation.security = sanitizeSecurity([{ [defaultScheme]: [] }], schemes);
+      const responses = operation.responses;
+      if (!responses["401"]) responses["401"] = { description: "Unauthorized" };
+    }
+    spec.paths[openApiPath][method] = operation;
+  }
+  if (refSchemas.size > 0) {
+    const schemas = spec.components.schemas;
+    for (const name of refSchemas) {
+      if (name in registeredSchemas && !(name in schemas)) {
+        schemas[name] = registeredSchemas[name];
+      }
+    }
+  }
+  if (usedTags.length > 0) {
+    spec.tags = usedTags.map((name) => ({ name }));
+  }
+  return spec;
+}
+function routeRequiresAuth(route, method) {
+  if (route.noAuth) return false;
+  if (WRITE_METHODS.has(method)) return true;
+  return route.secure === true;
+}
+function isIncludedPath(rawPath, include, exclude) {
+  for (const internal of ["/swagger", "/__dev"]) {
+    if (rawPath === internal || rawPath.startsWith(internal + "/")) return false;
+  }
+  if (include.length > 0 && !include.some((p) => rawPath === p || rawPath.startsWith(p))) {
+    return false;
+  }
+  if (exclude.some((p) => rawPath === p || rawPath.startsWith(p))) return false;
+  return true;
+}
+function parseRequestSchema(spec) {
+  if (spec === void 0) return null;
+  if (typeof spec === "string") return { name: spec, contentType: "application/json" };
+  return { name: spec.name, contentType: spec.contentType ?? "application/json" };
+}
+function parseResponseSchemas(spec) {
+  if (!spec) return [];
+  const out = [];
+  for (const [status, value] of Object.entries(spec)) {
+    if (typeof value === "string") {
+      out.push({ status, name: value, isList: false });
+    } else {
+      out.push({ status, name: value.name, isList: value.isList === true });
+    }
+  }
+  return out;
+}
+function resolveServers() {
+  const raw = (process.env.TINA4_SWAGGER_SERVERS ?? "").trim();
+  const urls = raw.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+  if (urls.length > 0) return urls.map((url) => ({ url }));
+  const dev = (process.env.SWAGGER_DEV_URL ?? "").trim();
+  return dev.length > 0 ? [{ url: dev }] : [{ url: "/" }];
+}
+function modelToSchema(model) {
+  const properties = {};
+  const required = [];
+  for (const [name, def] of Object.entries(model.fields)) {
+    properties[name] = fieldToSchemaProperty(def);
+    if (def.required && !def.primaryKey) {
+      required.push(name);
+    }
+  }
+  return {
+    type: "object",
+    properties,
+    ...required.length > 0 ? { required } : {}
+  };
+}
+function fieldToSchemaProperty(def) {
+  const prop = {};
+  switch (def.type) {
+    case "string":
+    case "text":
+      prop.type = "string";
+      if (def.maxLength) prop.maxLength = def.maxLength;
+      if (def.minLength) prop.minLength = def.minLength;
+      if (def.pattern) prop.pattern = def.pattern;
+      break;
+    case "integer":
+      prop.type = "integer";
+      if (def.min !== void 0) prop.minimum = def.min;
+      if (def.max !== void 0) prop.maximum = def.max;
+      break;
+    case "number":
+    case "numeric":
+      prop.type = "number";
+      if (def.min !== void 0) prop.minimum = def.min;
+      if (def.max !== void 0) prop.maximum = def.max;
+      break;
+    case "boolean":
+      prop.type = "boolean";
+      break;
+    case "datetime":
+      prop.type = "string";
+      prop.format = "date-time";
+      break;
+    case "foreignKey":
+      prop.type = "integer";
+      break;
+    case "json":
+      prop.type = "object";
+      break;
+    default:
+      prop.type = "string";
+  }
+  if (def.default !== void 0) prop.default = def.default;
+  if (def.primaryKey && def.autoIncrement) {
+    prop.readOnly = true;
+  }
+  return prop;
+}
+function inferSchema(value) {
+  if (Array.isArray(value)) {
+    return { type: "array", items: value.length > 0 ? inferSchema(value[0]) : {} };
+  }
+  if (value !== null && typeof value === "object") {
+    const properties = {};
+    for (const [k, v] of Object.entries(value)) {
+      properties[k] = inferSchema(v);
+    }
+    return { type: "object", properties };
+  }
+  if (typeof value === "boolean") return { type: "boolean" };
+  if (typeof value === "number") return { type: Number.isInteger(value) ? "integer" : "number" };
+  return { type: "string" };
+}
+function patternToOpenAPI(pattern) {
+  return pattern.replace(/\[\.\.\.(\w+)\]/g, "{$1}").replace(/\[(\w+)\]/g, "{$1}");
+}
+function extractPathParams(pattern) {
+  const params = [];
+  const regex = /\[(?:\.\.\.)?(\w+)\]/g;
+  let match;
+  while ((match = regex.exec(pattern)) !== null) {
+    params.push(match[1]);
+  }
+  return params;
+}
+function inferTags(pattern) {
+  const parts = pattern.split("/").filter(Boolean);
+  const apiIndex = parts.indexOf("api");
+  if (apiIndex !== -1 && parts[apiIndex + 1]) {
+    return [parts[apiIndex + 1]];
+  }
+  return parts.length > 0 ? [parts[0]] : ["default"];
+}
+function inferModelFromPath(pattern) {
+  const parts = pattern.split("/").filter(Boolean);
+  const apiIndex = parts.indexOf("api");
+  if (apiIndex === -1 || !parts[apiIndex + 1]) return null;
+  const candidate = parts[apiIndex + 1];
+  const rest = parts.slice(apiIndex + 2);
+  if (rest.length === 0) return candidate;
+  if (rest.length === 1 && /^[[{]\.{0,3}\w+[\]}]$/.test(rest[0])) return candidate;
+  return null;
+}
+function uniqueOperationId(method, openApiPath, seen) {
+  const base = (method + openApiPath.replace(/[/{}]/g, "_")).replace(/_+/g, "_").replace(/_$/, "");
+  let oid = base;
+  let n = 2;
+  while (seen.has(oid)) {
+    oid = `${base}_${n}`;
+    n += 1;
+  }
+  seen.add(oid);
+  return oid;
+}
+
+// src/ui.ts
+function swaggerUiCdn() {
+  return (process.env.TINA4_SWAGGER_UI_CDN ?? "https://unpkg.com/swagger-ui-dist@5").replace(/\/+$/, "");
+}
+var SWAGGER_UI_HTML = (specUrl) => `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>Tina4 API Documentation</title>
+  <link rel="stylesheet" href="${swaggerUiCdn()}/swagger-ui.css">
+  <style>
+    body { margin: 0; background: #fafafa; }
+    .topbar { display: none !important; }
+  </style>
+</head>
+<body>
+  <div id="swagger-ui"></div>
+  <script src="${swaggerUiCdn()}/swagger-ui-bundle.js"></script>
+  <script>
+    SwaggerUIBundle({
+      url: "${specUrl}",
+      dom_id: '#swagger-ui',
+      deepLinking: true,
+      presets: [SwaggerUIBundle.presets.apis, SwaggerUIBundle.SwaggerUIStandalonePreset],
+      layout: "BaseLayout",
+    });
+  </script>
+</body>
+</html>`;
+function swaggerEnabled() {
+  const raw = (process.env.TINA4_SWAGGER_ENABLED ?? "").trim().toLowerCase();
+  if (raw === "") {
+    const debug = (process.env.TINA4_DEBUG ?? "").trim().toLowerCase();
+    return ["true", "1", "yes", "on"].includes(debug);
+  }
+  return ["true", "1", "yes", "on"].includes(raw);
+}
+function createSwaggerRoutes(getSpec) {
+  return [
+    {
+      method: "GET",
+      pattern: "/swagger",
+      handler: async (_req, res) => {
+        res.html(SWAGGER_UI_HTML("/swagger/openapi.json"));
+      }
+    },
+    {
+      method: "GET",
+      pattern: "/swagger/openapi.json",
+      handler: async (_req, res) => {
+        res.json(getSpec());
+      }
+    }
+  ];
+}
+export {
+  addSchema,
+  addSecurityScheme,
+  createSwaggerRoutes,
+  generate,
+  resetRegistry,
+  swaggerEnabled
+};

package/packages/cli/bin/tina4nodejs

@@ -1,10 +0,0 @@
-#!/bin/sh
-# Resolve symlinks to find the real script location
-SCRIPT="$0"
-while [ -L "$SCRIPT" ]; do
-  DIR="$(cd -P "$(dirname "$SCRIPT")" && pwd)"
-  SCRIPT="$(readlink "$SCRIPT")"
-  [ "${SCRIPT%"${SCRIPT#?}"}" != "/" ] && SCRIPT="$DIR/$SCRIPT"
-done
-DIR="$(cd -P "$(dirname "$SCRIPT")" && pwd)"
-exec npx tsx "$DIR/../src/bin.ts" "$@"