@tiangong-lca/mcp-server 0.0.27 → 0.0.28

package/dist/src/tools/db_crud.js

@@ -1,11 +1,11 @@
 import { createClient, FunctionRegion } from '@supabase/supabase-js';
-import { createContact, createFlow, createLifeCycleModel, createProcess, createSource, } from '@tiangong-lca/tidas-sdk/core';
 import { z } from 'zod';
 import { supabase_base_url, supabase_publishable_key } from '../_shared/config.js';
 import { resolveSupabaseAccessToken } from '../_shared/supabase_session.js';
 const allowedTables = ['contacts', 'flows', 'lifecyclemodels', 'processes', 'sources'];
 const tableSchema = z.enum(allowedTables);
 const UPDATE_FUNCTION_NAME = 'update_data';
+const MAX_VALIDATION_ERROR_LENGTH = 4_000;
 const tablePrimaryKey = {
     contacts: 'id',
     flows: 'id',
@@ -16,21 +16,13 @@ const tablePrimaryKey = {
 function getPrimaryKeyColumn(table) {
     return tablePrimaryKey[table] ?? 'id';
 }
-const jsonValueSchema = z.lazy(() => z.union([
-    z.string(),
-    z.number(),
-    z.boolean(),
-    z.null(),
-    z.array(jsonValueSchema),
-    z.record(jsonValueSchema),
-]));
 const filterValueSchema = z.union([
     z.string(),
     z.number(),
     z.boolean(),
     z.null(),
 ]);
-const filtersSchema = z.record(filterValueSchema);
+const filtersSchema = z.record(z.string(), filterValueSchema);
 const toolParamsSchema = {
     operation: z
         .enum(['select', 'insert', 'update', 'delete'])
@@ -55,7 +47,8 @@ const toolParamsSchema = {
     filters: filtersSchema
         .optional()
         .describe('Optional equality filters as JSON object, e.g. { "name": "Example" }. Only used for select operations. Leave empty for insert/update/delete operations.'),
-    jsonOrdered: jsonValueSchema
+    jsonOrdered: z
+        .unknown()
         .optional()
         .describe('JSON value persisted into json_ordered (required for insert/update; omit for select/delete).'),
 };
@@ -123,6 +116,36 @@ const refinedInputSchema = z
             break;
     }
 });
+let tidasValidationFactoryMapPromise;
+function summarizeError(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    try {
+        const serialized = JSON.stringify(error);
+        if (!serialized) {
+            return String(error);
+        }
+        return serialized.length > MAX_VALIDATION_ERROR_LENGTH
+            ? `${serialized.slice(0, MAX_VALIDATION_ERROR_LENGTH)}...`
+            : serialized;
+    }
+    catch {
+        return String(error);
+    }
+}
+async function getTidasValidationFactoryMap() {
+    if (!tidasValidationFactoryMapPromise) {
+        tidasValidationFactoryMapPromise = import('@tiangong-lca/tidas-sdk/core').then((module) => ({
+            contacts: module.createContact,
+            flows: module.createFlow,
+            lifecyclemodels: module.createLifeCycleModel,
+            processes: module.createProcess,
+            sources: module.createSource,
+        }));
+    }
+    return tidasValidationFactoryMapPromise;
+}
 function requireAccessToken(accessToken) {
     if (!accessToken) {
         throw new Error('An authenticated Supabase session is required for update operations. Provide a valid access token.');
@@ -135,44 +158,13 @@ function ensureRows(rows, errorMessage) {
     }
     return rows;
 }
-function validateJsonOrdered(table, jsonOrdered) {
+async function validateJsonOrdered(table, jsonOrdered) {
     try {
-        let validationResult;
-        switch (table) {
-            case 'contacts': {
-                const contact = createContact(jsonOrdered, { mode: 'strict' });
-                validationResult = contact.validate();
-                break;
-            }
-            case 'flows': {
-                const flow = createFlow(jsonOrdered, { mode: 'strict' });
-                validationResult = flow.validate();
-                break;
-            }
-            case 'lifecyclemodels': {
-                const lifecycleModel = createLifeCycleModel(jsonOrdered, { mode: 'strict' });
-                validationResult = lifecycleModel.validate();
-                break;
-            }
-            case 'processes': {
-                const process = createProcess(jsonOrdered, { mode: 'strict' });
-                validationResult = process.validate();
-                break;
-            }
-            case 'sources': {
-                const source = createSource(jsonOrdered, { mode: 'strict' });
-                validationResult = source.validate();
-                break;
-            }
-            default: {
-                const exhaustiveCheck = table;
-                throw new Error(`Unsupported table type: ${table}`);
-            }
-        }
+        const validationFactoryMap = await getTidasValidationFactoryMap();
+        const createValidator = validationFactoryMap[table];
+        const validationResult = createValidator(jsonOrdered, { mode: 'strict' }).validate();
         if (!validationResult.success) {
-            const errorDetails = validationResult.error?.issues
-                ? JSON.stringify(validationResult.error.issues, null, 2)
-                : JSON.stringify(validationResult.error);
+            const errorDetails = summarizeError(validationResult.error);
             throw new Error(`Validation failed for table "${table}". Errors: ${errorDetails}`);
         }
     }
@@ -246,11 +238,12 @@ async function handleInsert(supabase, input) {
     if (id === undefined) {
         throw new Error('id is required for insert operations.');
     }
-    validateJsonOrdered(table, jsonOrdered);
+    const jsonOrderedValue = jsonOrdered;
+    await validateJsonOrdered(table, jsonOrderedValue);
     const keyColumn = getPrimaryKeyColumn(table);
     const { data, error } = await supabase
         .from(table)
-        .insert([{ [keyColumn]: id, json_ordered: jsonOrdered }])
+        .insert([{ [keyColumn]: id, json_ordered: jsonOrderedValue }])
         .select();
     if (error) {
         console.error('Error inserting into the database:', error);
@@ -269,13 +262,14 @@ async function handleUpdate(supabase, accessToken, input) {
     if (jsonOrdered === undefined) {
         throw new Error('jsonOrdered is required for update operations.');
     }
-    validateJsonOrdered(table, jsonOrdered);
+    const jsonOrderedValue = jsonOrdered;
+    await validateJsonOrdered(table, jsonOrderedValue);
     const token = requireAccessToken(accessToken);
     const { data: functionPayload, error } = await supabase.functions.invoke(UPDATE_FUNCTION_NAME, {
         headers: {
             Authorization: `Bearer ${token}`,
         },
-        body: { id, version, table, data: { json_ordered: jsonOrdered } },
+        body: { id, version, table, data: { json_ordered: jsonOrderedValue } },
         region: FunctionRegion.UsEast1,
     });
     if (error) {

package/dist/src/tools/tidas_data_validation.js

@@ -50,7 +50,7 @@ const jsonValueSchema = z.lazy(() => z.union([
     z.boolean(),
     z.null(),
     z.array(jsonValueSchema),
-    z.record(jsonValueSchema),
+    z.record(z.string(), jsonValueSchema),
 ]));
 function validateTidasData(entityType, data) {
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiangong-lca/mcp-server",
-  "version": "0.0.27",
+  "version": "0.0.28",
   "description": "TianGong LCA MCP Server",
   "license": "MIT",
   "author": "Nan LI",
@@ -28,19 +28,19 @@
     "ncu:update": "npx npm-check-updates -u"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.25.3",
-    "@supabase/supabase-js": "^2.91.1",
-    "@tiangong-lca/tidas-sdk": "^0.1.29",
+    "@modelcontextprotocol/sdk": "^1.26.0",
+    "@supabase/supabase-js": "^2.95.3",
+    "@tiangong-lca/tidas-sdk": "^0.1.30",
     "@types/express": "^5.0.6",
-    "@upstash/redis": "^1.36.1",
+    "@upstash/redis": "^1.36.2",
     "aws-jwt-verify": "^5.1.1",
     "olca-ipc": "^2.2.1",
-    "zod": "^3.25.76"
+    "zod": "^4.3.6"
   },
   "devDependencies": {
     "@modelcontextprotocol/inspector": "^0.19.0",
     "dotenv-cli": "^11.0.0",
-    "npm-check-updates": "^19.3.1",
+    "npm-check-updates": "^19.3.2",
     "prettier": "^3.8.1",
     "prettier-plugin-organize-imports": "^4.3.0",
     "shx": "^0.4.0",