@enfyra/mcp-server 0.0.53 → 0.0.54

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@enfyra/mcp-server",
-  "version": "0.0.53",
+  "version": "0.0.54",
   "description": "MCP server for Enfyra - manage your Enfyra instance via Claude Code",
   "type": "module",
   "license": "MIT",
@@ -16,7 +16,8 @@
   "scripts": {
     "start": "node src/index.mjs",
     "dev": "node --watch src/index.mjs",
-    "mcp:config": "node src/index.mjs config"
+    "mcp:config": "node src/index.mjs config",
+    "test": "node --test"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",

package/src/lib/mcp-instructions.js

@@ -72,10 +72,10 @@ export function buildMcpServerInstructions(apiBaseUrl) {
     '- REST-first workflow for any feature: **`inspect_feature`** to locate candidates → **`inspect_table`** for table/field/relation/rule context → **`inspect_route`** for handlers/hooks/guards/permissions → **`test_rest_endpoint`** to verify the actual HTTP behavior.',
     '- Use **`create_column_rule`** for standard request validation, **`create_field_permission`** for per-field read/create/update rules, **`create_route_permission`** for authenticated route access, and **`create_guard`** for pre/post-auth request gates.',
     '- Prefer these REST inspection/operator tools over raw `query_table` on system tables when changing route behavior. They resolve ids, methods, route paths, code previews, and cache reloads for the model.',
-    '- If the user asks for a **new route**, **URL path**, **custom API endpoint**, **handler**, **pre-hook**, **post-hook**, or to **test** that kind of logic: use MCP **`create_route`** with **`mainTableId`** of an **existing** table (resolve id via **`get_all_tables`**, **`get_all_metadata`**, or **`get_all_routes`**).',
+    '- If the user asks for a **new route**, **URL path**, **custom API endpoint**, **handler**, **pre-hook**, **post-hook**, or to **test** that kind of logic: use MCP **`create_route`** and **omit `mainTableId`**. `mainTable` is only a marker for canonical table routes like `/orders`; custom paths such as `/orders/stats`, `/cloud/admin/hosts`, `/auth/login`, or `/me` must not set it.',
     '- **Wrong pattern:** calling **`create_table`** just to get an HTTP path, then overriding handlers on the **default** auto route `/{table_name}`. That adds unnecessary schema and breaks the usual CRUD surface for that table.',
     '- **`create_table`** is only when the user needs **new persisted data** (new entity + columns). It is **not** the right tool when the goal is only a new path or custom script.',
-    '- **Right pattern:** **`create_route`** → optional **`create_handler`** / **`create_pre_hook`** / **`create_post_hook`** on **that route’s id** (from **`get_all_routes`** after create). Same underlying table can have **multiple** routes (e.g. default CRUD at `/orders` and custom `/orders/stats` both pointing at `mainTable` orders).',
+    '- **Right pattern:** **`create_route`** without `mainTableId` → optional **`create_handler`** / **`create_pre_hook`** / **`create_post_hook`** on **that route’s id** (from **`get_all_routes`** after create). Handler/hook code must query explicit repos such as `$ctx.$repos.orders`; do not rely on `$repos.main` for custom routes.',
     '- **Handler contract:** `create_handler` takes `routeId`, `method` (or `methods` for batch), `sourceCode`, optional `scriptLanguage`, and optional `timeout`. Do **not** send `logic`, `name`, or `compiledCode`; backend CRUD rejects `logic` and `compiledCode` is generated by the server.',
     '',
     '### After a new table is created',
@@ -107,8 +107,9 @@ export function buildMcpServerInstructions(apiBaseUrl) {
     '',
     '### Relation field format (create_record / update_record)',
 '- For generic MCP `create_record` and `update_record`, the `data` argument is a **JSON string**, not a JavaScript object. Example: `data: "{\\"name\\":\\"Starter\\"}"`. If the host gives a validation error saying `data` expected string, stringify the object before calling the tool.',
-'- Relation fields (mainTable, publishedMethods, availableMethods, handlers, preHooks, postHooks, etc.) use **object references with `id`**:',
-'  - **Many-to-one:** `"mainTable": {"id": 4}` (single object with id)',
+'- Relation fields (publishedMethods, availableMethods, handlers, preHooks, postHooks, etc.) use **object references with `id`**:',
+'- **mainTable warning:** do not set `mainTable` on custom routes. It is reserved for canonical table routes only.',
+'  - **Many-to-one:** `"someRelation": {"id": 4}` (single object with id)',
 '  - **One-to-many / many-to-many:** `"publishedMethods": [{"id": 1}, {"id": 2}]` (array of objects with id)',
 '- **Method IDs** (for REST route publishedMethods, availableMethods, skipRoleGuardMethods): GET=1, POST=2, PATCH=3, DELETE=4. Query `method_definition` table if unsure.',
 '- **Wrong:** `"publishedMethods": ["GET"]` or `"publishedMethods": [{"method": "GET"}]` — rejected or silently ignored.',
@@ -198,10 +199,10 @@ export function buildMcpServerInstructions(apiBaseUrl) {
     '- **Not all system tables have a REST route.** `query_table`, `find_one_record`, `create_record`, etc. all go through the dynamic REST API and will return **404** if the table has no registered route.',
     '- **`column_definition` and `session_definition` have NO route** — do NOT call `query_table("column_definition", …)` or `query_table("session_definition", …)`. They will 404.',
     '- Do not invent singular/legacy system route names such as `hook_definition`, `oauth_provider_definition`, or physical FK tables. If a route name is not listed by `get_all_routes`, it is not a REST endpoint for generic CRUD. Use the concrete tables (`pre_hook_definition`, `post_hook_definition`, `oauth_config_definition`, etc.) or the dedicated MCP tool.',
-    '- To check which tables are accessible via MCP tools, call `get_all_routes` and look for the route whose `mainTable.id` matches the table you need, or `get_all_metadata` to see all table names.',
+    '- To check which tables have canonical CRUD routes, call `get_all_routes` and look for `mainTable`. Custom routes intentionally have no `mainTable`; inspect their handlers/hooks to see which repos they touch.',
     '- **Tables confirmed to have REST routes (system):** `bootstrap_script_definition`, `column_rule_definition`, `cors_origin_definition`, `extension_definition`, `field_permission_definition`, `file_definition`, `file_permission_definition`, `flow_definition`, `flow_execution_definition`, `flow_step_definition`, `folder_definition`, `gql_definition`, `guard_definition`, `guard_rule_definition`, `menu_definition`, `method_definition`, `oauth_account_definition`, `oauth_config_definition`, `package_definition`, `post_hook_definition`, `pre_hook_definition`, `relation_definition`, `role_definition`, `route_definition`, `route_handler_definition`, `route_permission_definition`, `schema_migration_definition`, `setting_definition`, `storage_config_definition`, `table_definition`, `user_definition`, `websocket_definition`, `websocket_event_definition`.',
-    '- **Tables without REST routes (internal/system only):** `column_definition`, `session_definition`. Columns are managed indirectly via cascade on `table_definition` (POST/PATCH with columns arrays). The `create_table`, `create_column`/`add_column`, `update_column`, and `delete_column`/`remove_column` MCP tools handle this automatically.',
-    '- Use `create_column`/`add_column` for new scalar fields. These tools accept column metadata such as `isNullable`, `isUnique`, `isPublished`, `isPrimary`, `isGenerated`, `isSystem`, `defaultValue`, `description`, and `options`; set `isPublished=false` directly when creating secret/internal fields such as `*_encrypted`. When patching an existing table, only persisted columns with an `id`/`_id` belong in the cascade payload; metadata projections such as `createdAt`, `updatedAt`, or relation-derived FK display fields without an id are not valid column-definition patch rows.',
+    '- **Tables without REST routes (internal/system only):** `column_definition`, `session_definition`. Columns are managed indirectly via cascade on `table_definition` (POST/PATCH with columns arrays). The `create_table`, `create_column`/`add_column`, `update_column`, and `delete_column`/`remove_column` MCP tools handle this automatically by reading full table metadata first.',
+    '- Use `create_column`/`add_column` for new scalar fields. These tools accept column metadata such as `isNullable`, `isUnique`, `isPublished`, `isPrimary`, `isGenerated`, `isSystem`, `defaultValue`, `description`, and `options`; set `isPublished=false` directly when creating secret/internal fields such as `*_encrypted`. When patching an existing table, only persisted columns with an `id`/`_id` belong in the cascade payload; metadata projections such as `createdAt`, `updatedAt`, or relation-derived FK display fields without an id are not valid column-definition patch rows. Never rebuild a schema cascade from `table_definition?fields=columns.*`, because nested relation fields may be paginated/truncated.',
     '- Prefer `create_relation`/`add_relation` and `delete_relation`/`remove_relation` for relation schema changes because they preserve the full table relation list and handle schema-confirm retry. Direct `create_record` on `relation_definition` only edits metadata and is not the canonical schema migration path.',
     '',
     '### Body validation & column rules',
@@ -220,7 +221,7 @@ export function buildMcpServerInstructions(apiBaseUrl) {
     '',
     '### Resolving the real REST path',
     '- Do **not** assume `route_definition.path` always equals `table_definition.name`. Paths are data-driven (custom prefixes, renames, multiple routes per table).',
-    '- When unsure of the URL path, use MCP **`get_all_routes`** (or **`get_all_metadata`**) to read each route’s **path** and **mainTable** before stating a full URL.',
+    '- When unsure of the URL path, use MCP **`get_all_routes`** (or **`get_all_metadata`**) to read each route’s **path**. Treat `mainTable` as canonical CRUD-route metadata only, not as the owner table for custom routes.',
     '',
     '### MongoDB vs SQL primary key',
     '- On **SQL**, filters often use **`id`**. On **MongoDB**, documents may use **`_id`** — a filter for one row might be `{"_id":{"_eq":"..."}}` instead of `id`, depending on metadata.',

package/src/lib/table-tools.js

@@ -4,13 +4,42 @@
 import { z } from 'zod';
 import { fetchAPI } from './fetch.js';
 
+export function normalizeTablesFromMetadata(metadata) {
+  const tablesSource = metadata?.data?.tables || metadata?.tables || metadata?.data || [];
+  return Array.isArray(tablesSource)
+    ? tablesSource
+    : Object.values(tablesSource || {});
+}
+
+export function resolveTableFromMetadata(metadata, tableId) {
+  return normalizeTablesFromMetadata(metadata)
+    .find((table) => String(getId(table)) === String(tableId)) || null;
+}
+
 /**
- * Helper: fetch table with columns and relations
+ * Helper: fetch table with full columns and relations.
+ * Dynamic table_definition relation fields can be paginated/truncated, so schema
+ * cascade tools must use /metadata as the complete source of columns/relations.
  */
-async function fetchTableWithDetails(ENFYRA_API_URL, tableId) {
+export async function fetchTableWithDetails(ENFYRA_API_URL, tableId) {
   const filter = encodeURIComponent(JSON.stringify({ id: { _eq: tableId } }));
-  const result = await fetchAPI(ENFYRA_API_URL, `/table_definition?filter=${filter}&limit=1&fields=*,columns.*,relations.*`);
-  return result?.data?.[0] || result?.[0] || null;
+  const [tableResult, metadata] = await Promise.all([
+    fetchAPI(ENFYRA_API_URL, `/table_definition?filter=${filter}&limit=1&fields=*`),
+    fetchAPI(ENFYRA_API_URL, '/metadata'),
+  ]);
+  const tableData = tableResult?.data?.[0] || tableResult?.[0] || null;
+  const metadataTable = resolveTableFromMetadata(metadata, tableId);
+  if (!metadataTable) {
+    throw new Error(`Full metadata for table ${tableId} was not found; refusing schema cascade patch.`);
+  }
+  if (!Array.isArray(metadataTable.columns)) {
+    throw new Error(`Full metadata for table ${tableId} did not include columns; refusing schema cascade patch.`);
+  }
+  return {
+    ...(tableData || metadataTable),
+    columns: metadataTable.columns,
+    relations: Array.isArray(metadataTable.relations) ? metadataTable.relations : [],
+  };
 }
 
 /**
@@ -99,6 +128,41 @@ function getPatchableColumns(columns) {
     .map(normalizeColumnForTablePatch);
 }
 
+function getMissingIds(beforeIds, afterIds, excludedIds = []) {
+  const afterSet = new Set(afterIds.map(String));
+  const excludedSet = new Set(excludedIds.map(String));
+  return beforeIds
+    .map(String)
+    .filter((id) => !excludedSet.has(id) && !afterSet.has(id));
+}
+
+async function verifyColumnCascade(ENFYRA_API_URL, tableId, beforeIds, {
+  action,
+  columnId,
+  columnName,
+}) {
+  const tableData = await fetchTableWithDetails(ENFYRA_API_URL, tableId);
+  const afterColumns = getPatchableColumns(tableData.columns);
+  const afterIds = afterColumns.map((column) => String(getId(column)));
+  const excludedIds = action === 'delete' ? [columnId] : [];
+  const missingIds = getMissingIds(beforeIds, afterIds, excludedIds);
+  if (missingIds.length > 0) {
+    throw new Error(`Schema cascade verification failed: unrelated column ids disappeared: ${missingIds.join(', ')}`);
+  }
+
+  if (action === 'create' && !afterColumns.some((column) => column.name === columnName)) {
+    throw new Error(`Schema cascade verification failed: column "${columnName}" was not found after create.`);
+  }
+  if (action === 'delete' && afterIds.includes(String(columnId))) {
+    throw new Error(`Schema cascade verification failed: column ${columnId} still exists after delete.`);
+  }
+  if (action === 'update' && !afterIds.includes(String(columnId))) {
+    throw new Error(`Schema cascade verification failed: column ${columnId} was not found after update.`);
+  }
+
+  return afterColumns;
+}
+
 function buildColumnDefinition({
   name,
   type,
@@ -138,8 +202,13 @@ export function registerTableTools(server, ENFYRA_API_URL) {
     }
 
     const existingColumns = getPatchableColumns(tableData.columns);
+    const beforeIds = existingColumns.map((column) => String(getId(column)));
     const newCol = buildColumnDefinition(args);
     const result = await patchTableAutoConfirm(ENFYRA_API_URL, args.tableId, { columns: [...existingColumns, newCol] });
+    await verifyColumnCascade(ENFYRA_API_URL, args.tableId, beforeIds, {
+      action: 'create',
+      columnName: args.name,
+    });
 
     return {
       content: [{ type: 'text', text: `Column "${args.name}" added to table ${args.tableId}.\n\n${JSON.stringify(result, null, 2)}` }],
@@ -170,12 +239,20 @@ export function registerTableTools(server, ENFYRA_API_URL) {
       return { content: [{ type: 'text', text: `Error: Table with ID ${tableId} not found.` }] };
     }
 
-    const columns = (tableData.columns || [])
-      .filter((col) => getId(col) !== null)
+    const existingColumns = getPatchableColumns(tableData.columns);
+    const beforeIds = existingColumns.map((column) => String(getId(column)));
+    if (!beforeIds.includes(String(columnId))) {
+      throw new Error(`Column ${columnId} was not found on table ${tableId}; refusing schema cascade patch.`);
+    }
+
+    const columns = existingColumns
       .filter(col => String(getId(col)) !== String(columnId))
-      .map(normalizeColumnForTablePatch);
 
     const result = await patchTableAutoConfirm(ENFYRA_API_URL, tableId, { columns });
+    await verifyColumnCascade(ENFYRA_API_URL, tableId, beforeIds, {
+      action: 'delete',
+      columnId,
+    });
 
     return {
       content: [{ type: 'text', text: `Column ${columnId} deleted from table ${tableId}.\n\n${JSON.stringify(result, null, 2)}` }],
@@ -256,7 +333,7 @@ export function registerTableTools(server, ENFYRA_API_URL) {
     'create_table',
     [
       'Create a new table definition with an auto-included `id` primary key column.',
-      '**Not** for adding a custom API path or handler only — for that use **`create_route`** with an existing `mainTableId`. Use **`create_table`** when the user needs new stored data (new entity).',
+      '**Not** for adding a custom API path or handler only — for that use **`create_route`** without `mainTableId`. Use **`create_table`** when the user needs new stored data (new entity).',
       'PREFERRED: pass `columns` and `relations` params as JSON arrays to create a table WITH columns and relations in one call (cascade). Only use create_column/create_relation separately when adding to an existing table later.',
       'Indexes and uniques are first-class table metadata. Use `indexes` for query performance and `uniques` for data integrity. Each entry is a logical field group such as [["member","isRead","conversation"]] or [{"value":["message","member"]}]. Relation property names are allowed; Enfyra resolves them to physical FK columns.',
       'Relations are supported in this same create_table call when the target table already exists. Each relation uses { targetTable, type, propertyName, inversePropertyName?, mappedBy?, isNullable?, onDelete? }; targetTable may be a table id or {id}.',
@@ -383,7 +460,7 @@ export function registerTableTools(server, ENFYRA_API_URL) {
     [
       'Add a column to an existing table via PATCH /table_definition/{tableId}.',
       'Columns are managed through cascade with table_definition — there is NO direct /column_definition endpoint.',
-      'This tool fetches existing columns, keeps only persisted column rows with id/_id, appends the new one, and PATCHes the table.',
+      'This tool reads full table metadata, keeps only persisted column rows with id/_id, appends the new one, PATCHes the table, and verifies unrelated columns survived.',
       'Generated metadata projections such as createdAt, updatedAt, or relation-derived FK display fields without id are not valid cascade rows and are skipped.',
       'Run schema changes sequentially — migration locks DB per operation.',
     ].join(' '),
@@ -398,7 +475,7 @@ export function registerTableTools(server, ENFYRA_API_URL) {
     [
       'Alias for create_column. Add a column to an existing table through the canonical table_definition cascade.',
       'Use this for schema additions, including hidden secret fields with isPublished=false.',
-      'Skips non-persisted generated/derived column metadata without id/_id when rebuilding the table columns payload.',
+      'Reads full table metadata and skips non-persisted generated/derived column metadata without id/_id when rebuilding the table columns payload.',
       'Run schema changes sequentially — migration locks DB per operation.',
     ].join(' '),
     columnCreateSchema,
@@ -411,7 +488,7 @@ export function registerTableTools(server, ENFYRA_API_URL) {
     'update_column',
     [
       'Update an existing column on a table via PATCH /table_definition/{tableId}.',
-      'Fetches table columns, keeps only persisted rows with id/_id, modifies the target column, and PATCHes the table.',
+      'Reads full table metadata, keeps only persisted rows with id/_id, modifies the target column, PATCHes the table, and verifies unrelated columns survived.',
       'Generated metadata projections such as createdAt, updatedAt, or relation-derived FK display fields without id are skipped.',
       'Run schema changes sequentially — migration locks DB per operation.',
     ].join(' '),
@@ -432,7 +509,13 @@ export function registerTableTools(server, ENFYRA_API_URL) {
         return { content: [{ type: 'text', text: `Error: Table with ID ${tableId} not found.` }] };
       }
 
-      const columns = (tableData.columns || []).filter((col) => getId(col) !== null).map(col => {
+      const existingColumns = getPatchableColumns(tableData.columns);
+      const beforeIds = existingColumns.map((column) => String(getId(column)));
+      if (!beforeIds.includes(String(columnId))) {
+        throw new Error(`Column ${columnId} was not found on table ${tableId}; refusing schema cascade patch.`);
+      }
+
+      const columns = existingColumns.map(col => {
         const rest = normalizeColumnForTablePatch(col);
         if (String(getId(col)) === String(columnId)) {
           if (name !== undefined) rest.name = name;
@@ -447,6 +530,10 @@ export function registerTableTools(server, ENFYRA_API_URL) {
       });
 
       const result = await patchTableAutoConfirm(ENFYRA_API_URL, tableId, { columns });
+      await verifyColumnCascade(ENFYRA_API_URL, tableId, beforeIds, {
+        action: 'update',
+        columnId,
+      });
 
       return {
         content: [{ type: 'text', text: `Column ${columnId} updated on table ${tableId}.\n\n${JSON.stringify(result, null, 2)}` }],
@@ -460,7 +547,7 @@ export function registerTableTools(server, ENFYRA_API_URL) {
     'delete_column',
     [
       'Delete a column from a table via PATCH /table_definition/{tableId}.',
-      'Fetches table columns, keeps only persisted rows with id/_id, removes the target, and PATCHes the table.',
+      'Reads full table metadata, keeps only persisted rows with id/_id, removes the target, PATCHes the table, and verifies unrelated columns survived.',
       'The physical column is dropped from the database. System columns (id, createdAt, updatedAt) cannot be deleted.',
       'Run schema changes sequentially — migration locks DB per operation.',
     ].join(' '),
@@ -475,7 +562,7 @@ export function registerTableTools(server, ENFYRA_API_URL) {
     [
       'Alias for delete_column. Remove a column through the canonical table_definition cascade.',
       'This drops the physical column. Confirm destructive schema changes before calling.',
-      'Skips non-persisted generated/derived column metadata without id/_id when rebuilding the table columns payload.',
+      'Reads full table metadata and skips non-persisted generated/derived column metadata without id/_id when rebuilding the table columns payload.',
       'Run schema changes sequentially — migration locks DB per operation.',
     ].join(' '),
     columnDeleteSchema,

package/src/mcp-server-entry.mjs

@@ -32,7 +32,7 @@ const CAPABILITY_AREAS = [
   {
     area: 'Dynamic REST API',
     tables: ['route_definition', 'route_handler_definition', 'pre_hook_definition', 'post_hook_definition', 'route_permission_definition', 'method_definition'],
-    workflow: 'Create paths with create_route on an existing main table, then add handlers/hooks. REST methods are GET/POST/PATCH/DELETE.',
+    workflow: 'Create custom paths with create_route without mainTableId, then add handlers/hooks. mainTableId is only for canonical table routes like /table_name. REST methods are GET/POST/PATCH/DELETE.',
   },
   {
     area: 'Auth, roles, sessions, OAuth',
@@ -1387,15 +1387,16 @@ server.tool('get_all_routes', 'List route definitions with minimal fields. Call
 server.tool(
   'create_route',
   [
-    '**Use this when the user wants a new REST API route or path** — not `create_table`. A route links a URL path to an existing table (`mainTableId`) and sets HTTP methods.',
-    'Do NOT create a new table_definition only to expose an endpoint; pick `mainTableId` from existing metadata unless the user explicitly needs new tables/columns.',
+    '**Use this when the user wants a new REST API route or path** — not `create_table`. Custom routes must omit `mainTableId`.',
+    '`mainTableId` is only a marker for canonical table routes such as `/orders`; do not set it for `/orders/stats`, `/cloud/admin/hosts`, `/auth/login`, or any custom path.',
+    'Do NOT create a new table_definition only to expose an endpoint; create a route without `mainTableId`, then have the handler/hook query explicit repos such as `$ctx.$repos.orders`.',
     'availableMethods = which REST verbs the route responds to. publishedMethods = which REST verbs are public (no auth). GraphQL is enabled separately through gql_definition/update_table graphqlEnabled.',
     'After creation the tool auto-reloads routes. Then create handlers for specific methods via create_handler on this route id.',
-    'Flow: resolve table id → create_route → create_handler (per method) → optionally create_pre_hook / create_post_hook → test via HTTP or admin test APIs (see server instructions).',
+    'Flow: create_route → create_handler (per method) → optionally create_pre_hook / create_post_hook → test via HTTP or admin test APIs (see server instructions).',
   ].join(' '),
   {
     path: z.string().describe('URL path, must start with / (e.g., "/my-endpoint")'),
-    mainTableId: z.union([z.string(), z.number()]).describe('ID of the table_definition this route operates on. The route\'s $repos.main will query this table.'),
+    mainTableId: z.union([z.string(), z.number()]).optional().describe('Only set for the canonical table route `/<table_name>`. Omit for every custom route.'),
     methods: z.array(z.enum(['GET', 'POST', 'PATCH', 'DELETE']))
       .describe('HTTP methods this route supports (availableMethods). Common: ["GET","POST","PATCH","DELETE"]'),
     publishedMethods: z.array(z.enum(['GET', 'POST', 'PATCH', 'DELETE'])).optional()
@@ -1408,12 +1409,15 @@ server.tool(
 
     const body = {
       path: routePath.startsWith('/') ? routePath : '/' + routePath,
-      mainTable: { id: mainTableId },
       isEnabled,
       description,
       availableMethods: resolveMethodIds(methodMap, methods),
     };
 
+    if (mainTableId !== undefined && mainTableId !== null) {
+      body.mainTable = { id: mainTableId };
+    }
+
     if (publishedMethods && publishedMethods.length > 0) {
       body.publishedMethods = resolveMethodIds(methodMap, publishedMethods);
     }
@@ -1431,7 +1435,7 @@ server.tool(
       route: {
         id: getId(created),
         path: created?.path,
-        mainTableId,
+        mainTableId: mainTableId ?? null,
         availableMethods: methods,
         publishedMethods: publishedMethods || [],
       },