@superatomai/sdk-node 0.0.48-mds → 0.0.49-mds

package/dist/index.js

@@ -16278,6 +16278,131 @@ async function handleReportCompRequest(data, components, sendMessage, anthropicA
   logger.info(`[REPORT_COMP_REQ] Response sent to client ${response.wsId || data.from?.id}`);
 }
 
+// src/handlers/schema-sanitize.ts
+var FIELD_KEYS = [
+  "name",
+  "type",
+  "nativeType",
+  "nullable",
+  "isPrimaryKey",
+  "isForeignKey",
+  "description"
+];
+var ENTITY_KEYS = ["name", "fullName", "description", "rowCount"];
+var SOURCE_KEYS = ["id", "name", "type"];
+var RELATIONSHIP_KEYS = ["from", "to", "type", "keys"];
+var ROOT_KEYS = ["database", "databaseType", "description", "extractedAt"];
+function pick(source, keys) {
+  const out = {};
+  if (!source || typeof source !== "object") return out;
+  for (const key of keys) {
+    if (source[key] !== void 0) out[key] = source[key];
+  }
+  return out;
+}
+function asArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+function sanitizeField(field) {
+  const out = pick(field, FIELD_KEYS);
+  if (field?.references && typeof field.references === "object") {
+    out.references = pick(field.references, ["table", "column"]);
+  }
+  return out;
+}
+function sanitizeEntity(entity) {
+  const out = pick(entity, ENTITY_KEYS);
+  if (Array.isArray(entity?.fields)) out.fields = entity.fields.map(sanitizeField);
+  if (Array.isArray(entity?.columns)) out.columns = entity.columns.map(sanitizeField);
+  return out;
+}
+function sanitizeRelationship(relationship) {
+  return pick(relationship, RELATIONSHIP_KEYS);
+}
+function sanitizeSchemaBody(body) {
+  const out = {};
+  if (Array.isArray(body?.entities)) out.entities = body.entities.map(sanitizeEntity);
+  if (Array.isArray(body?.tables)) out.tables = body.tables.map(sanitizeEntity);
+  if (Array.isArray(body?.relationships)) {
+    out.relationships = body.relationships.map(sanitizeRelationship);
+  }
+  return out;
+}
+function sanitizeSource(source) {
+  const out = pick(source, SOURCE_KEYS);
+  const inner = source?.schema;
+  if (inner && typeof inner === "object") out.schema = sanitizeSchemaBody(inner);
+  return out;
+}
+function sanitizeSchemaForClient(schemaData) {
+  if (!schemaData || typeof schemaData !== "object") return null;
+  if (Array.isArray(schemaData)) return schemaData.map(sanitizeSource);
+  const out = pick(schemaData, ROOT_KEYS);
+  if (Array.isArray(schemaData.schema)) {
+    out.schema = schemaData.schema.map(sanitizeSource);
+  } else if (typeof schemaData.schema === "string") {
+    out.schema = schemaData.schema;
+  }
+  return { ...out, ...sanitizeSchemaBody(schemaData) };
+}
+function generateSanitizedSchemaDocumentation(sanitized) {
+  if (!sanitized || typeof sanitized !== "object") return "No database schema available.";
+  const lines = [];
+  const renderEntities = (entities, heading) => {
+    if (!entities.length) return;
+    if (heading) {
+      lines.push(`SOURCE: ${heading}`);
+      lines.push("");
+    }
+    for (const entity of entities) {
+      lines.push(`TABLE: ${entity.fullName || entity.name}`);
+      if (entity.description) lines.push(`Description: ${entity.description}`);
+      if (typeof entity.rowCount === "number") {
+        lines.push(`Row Count: ~${entity.rowCount.toLocaleString()}`);
+      }
+      lines.push("Columns:");
+      for (const field of asArray(entity.fields).concat(asArray(entity.columns))) {
+        let line = `  - ${field.name}: ${field.type}`;
+        if (field.isPrimaryKey) line += " (PRIMARY KEY)";
+        if (field.isForeignKey && field.references) {
+          line += ` (FK -> ${field.references.table}.${field.references.column})`;
+        }
+        if (field.nullable === false) line += " NOT NULL";
+        if (field.description) line += ` - ${field.description}`;
+        lines.push(line);
+      }
+      lines.push("");
+    }
+  };
+  const renderRelationships = (relationships) => {
+    if (!relationships.length) return;
+    lines.push("TABLE RELATIONSHIPS:");
+    lines.push("");
+    for (const rel of relationships) {
+      lines.push(`${rel.from} -> ${rel.to} (${rel.type}): ${asArray(rel.keys).join(" = ")}`);
+    }
+    lines.push("");
+  };
+  const sources = Array.isArray(sanitized) ? sanitized : Array.isArray(sanitized.schema) ? sanitized.schema : null;
+  if (sources) {
+    for (const source of sources) {
+      renderEntities(
+        asArray(source.schema?.entities).concat(asArray(source.schema?.tables)),
+        `${source.name} (${source.type})`
+      );
+      renderRelationships(asArray(source.schema?.relationships));
+    }
+    return lines.join("\n");
+  }
+  if (sanitized.database) lines.push(`Database: ${sanitized.database}`);
+  if (typeof sanitized.schema === "string") lines.push(`Schema: ${sanitized.schema}`);
+  if (sanitized.description) lines.push(`Description: ${sanitized.description}`);
+  lines.push("");
+  renderEntities(asArray(sanitized.entities).concat(asArray(sanitized.tables)));
+  renderRelationships(asArray(sanitized.relationships));
+  return lines.join("\n");
+}
+
 // src/handlers/schema-request.ts
 async function handleSchemaRequest(message, sendMessage) {
   const startTime = Date.now();
@@ -16300,11 +16425,12 @@ async function handleSchemaRequest(message, sendMessage) {
       sendMessage(response2);
       return;
     }
+    const safeSchema = sanitizeSchemaForClient(schemaData);
     const responseData = {
-      schema: schemaData
+      schema: safeSchema
     };
     if (formatted) {
-      responseData.formatted = schema.generateSchemaDocumentation();
+      responseData.formatted = generateSanitizedSchemaDocumentation(safeSchema);
     }
     const executionMs = Date.now() - startTime;
     logger.info(`[SchemaRequest] Schema retrieved successfully in ${executionMs}ms`);