@centrali-io/centrali-mcp 4.2.1 → 4.2.2

package/src/tools/orchestrations.ts

@@ -206,4 +206,171 @@ export function registerOrchestrationTools(server: McpServer, sdk: CentraliSDK)
       }
     }
   );
+
+  server.tool(
+    "create_orchestration",
+    "Create a new orchestration workflow. Orchestrations chain compute functions together in multi-step workflows.",
+    {
+      slug: z.string().describe("URL-friendly unique slug (e.g., 'order-processing')"),
+      name: z.string().describe("Human-readable name"),
+      description: z.string().optional().describe("Optional description of the workflow"),
+      trigger: z
+        .record(z.string(), z.any())
+        .describe("Trigger configuration object. Must include 'type' (on-demand, event-driven, scheduled, webhook)"),
+      steps: z
+        .array(z.record(z.string(), z.any()))
+        .describe("Array of step definitions. Each step has id, type, functionId, and optional onSuccess/onFailure routing"),
+    },
+    async ({ slug, name, description, trigger, steps }) => {
+      try {
+        const input: Record<string, any> = { slug, name, trigger, steps };
+        if (description !== undefined) input.description = description;
+
+        const result = await sdk.orchestrations.create(input as any);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result.data, null, 2) }],
+        };
+      } catch (error: unknown) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: formatError(error, `creating orchestration '${slug}'`),
+            },
+          ],
+          isError: true,
+        };
+      }
+    }
+  );
+
+  server.tool(
+    "update_orchestration",
+    "Update an existing orchestration by ID. Only include the fields you want to change.",
+    {
+      orchestrationId: z.string().describe("The orchestration ID (UUID) to update"),
+      name: z.string().optional().describe("Updated name"),
+      description: z.string().optional().describe("Updated description"),
+      status: z
+        .enum(["draft", "active", "paused"])
+        .optional()
+        .describe("Updated status"),
+      trigger: z
+        .record(z.string(), z.any())
+        .optional()
+        .describe("Updated trigger configuration"),
+      steps: z
+        .array(z.record(z.string(), z.any()))
+        .optional()
+        .describe("Updated step definitions"),
+    },
+    async ({ orchestrationId, name, description, status, trigger, steps }) => {
+      try {
+        const input: Record<string, any> = {};
+        if (name !== undefined) input.name = name;
+        if (description !== undefined) input.description = description;
+        if (status !== undefined) input.status = status;
+        if (trigger !== undefined) input.trigger = trigger;
+        if (steps !== undefined) input.steps = steps;
+
+        const result = await sdk.orchestrations.update(orchestrationId, input as any);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result.data, null, 2) }],
+        };
+      } catch (error: unknown) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: formatError(error, `updating orchestration '${orchestrationId}'`),
+            },
+          ],
+          isError: true,
+        };
+      }
+    }
+  );
+
+  server.tool(
+    "delete_orchestration",
+    "Delete an orchestration by ID. This also deletes all runs associated with the orchestration.",
+    {
+      orchestrationId: z.string().describe("The orchestration ID (UUID) to delete"),
+    },
+    async ({ orchestrationId }) => {
+      try {
+        await sdk.orchestrations.delete(orchestrationId);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Orchestration '${orchestrationId}' deleted successfully.`,
+            },
+          ],
+        };
+      } catch (error: unknown) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: formatError(error, `deleting orchestration '${orchestrationId}'`),
+            },
+          ],
+          isError: true,
+        };
+      }
+    }
+  );
+
+  server.tool(
+    "activate_orchestration",
+    "Activate an orchestration. Active orchestrations can be triggered by scheduled events, record events, and webhooks.",
+    {
+      orchestrationId: z.string().describe("The orchestration ID (UUID) to activate"),
+    },
+    async ({ orchestrationId }) => {
+      try {
+        const result = await sdk.orchestrations.activate(orchestrationId);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result.data, null, 2) }],
+        };
+      } catch (error: unknown) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: formatError(error, `activating orchestration '${orchestrationId}'`),
+            },
+          ],
+          isError: true,
+        };
+      }
+    }
+  );
+
+  server.tool(
+    "pause_orchestration",
+    "Pause an orchestration. Paused orchestrations cannot be triggered by any mechanism.",
+    {
+      orchestrationId: z.string().describe("The orchestration ID (UUID) to pause"),
+    },
+    async ({ orchestrationId }) => {
+      try {
+        const result = await sdk.orchestrations.pause(orchestrationId);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result.data, null, 2) }],
+        };
+      } catch (error: unknown) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: formatError(error, `pausing orchestration '${orchestrationId}'`),
+            },
+          ],
+          isError: true,
+        };
+      }
+    }
+  );
 }

package/src/tools/smart-queries.ts

@@ -100,4 +100,179 @@ export function registerSmartQueryTools(server: McpServer, sdk: CentraliSDK) {
       }
     }
   );
+
+  server.tool(
+    "get_smart_query",
+    "Get a smart query by ID. Returns the full query definition including filters, sort, and variable declarations.",
+    {
+      recordSlug: z.string().describe("The structure's record slug the query belongs to"),
+      queryId: z.string().describe("The smart query ID (UUID)"),
+    },
+    async ({ recordSlug, queryId }) => {
+      try {
+        const result = await sdk.smartQueries.get(recordSlug, queryId);
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(result.data, null, 2) },
+          ],
+        };
+      } catch (error: unknown) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: formatError(error, `getting smart query '${queryId}'`),
+            },
+          ],
+          isError: true,
+        };
+      }
+    }
+  );
+
+  server.tool(
+    "create_smart_query",
+    "Create a new smart query for a collection. Smart queries are reusable, parameterized queries with filter, sort, and variable support.",
+    {
+      recordSlug: z.string().describe("The structure's record slug to create the query for"),
+      name: z.string().describe("Display name for the smart query"),
+      description: z.string().optional().describe("Optional description"),
+      queryDefinition: z
+        .record(z.string(), z.any())
+        .describe("The query definition object with where, sort, limit, select, join, etc."),
+    },
+    async ({ recordSlug, name, description, queryDefinition }) => {
+      try {
+        const input: Record<string, any> = { name, queryDefinition };
+        if (description !== undefined) input.description = description;
+
+        const result = await sdk.smartQueries.create(recordSlug, input as any);
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(result.data, null, 2) },
+          ],
+        };
+      } catch (error: unknown) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: formatError(error, `creating smart query '${name}' for '${recordSlug}'`),
+            },
+          ],
+          isError: true,
+        };
+      }
+    }
+  );
+
+  server.tool(
+    "update_smart_query",
+    "Update an existing smart query. Only include the fields you want to change.",
+    {
+      recordSlug: z.string().describe("The structure's record slug the query belongs to"),
+      queryId: z.string().describe("The smart query ID (UUID) to update"),
+      name: z.string().optional().describe("Updated display name"),
+      description: z.string().optional().describe("Updated description"),
+      queryDefinition: z
+        .record(z.string(), z.any())
+        .optional()
+        .describe("Updated query definition object"),
+    },
+    async ({ recordSlug, queryId, name, description, queryDefinition }) => {
+      try {
+        const input: Record<string, any> = {};
+        if (name !== undefined) input.name = name;
+        if (description !== undefined) input.description = description;
+        if (queryDefinition !== undefined) input.queryDefinition = queryDefinition;
+
+        const result = await sdk.smartQueries.update(recordSlug, queryId, input as any);
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(result.data, null, 2) },
+          ],
+        };
+      } catch (error: unknown) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: formatError(error, `updating smart query '${queryId}'`),
+            },
+          ],
+          isError: true,
+        };
+      }
+    }
+  );
+
+  server.tool(
+    "delete_smart_query",
+    "Delete a smart query by ID.",
+    {
+      recordSlug: z.string().describe("The structure's record slug the query belongs to"),
+      queryId: z.string().describe("The smart query ID (UUID) to delete"),
+    },
+    async ({ recordSlug, queryId }) => {
+      try {
+        await sdk.smartQueries.delete(recordSlug, queryId);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Smart query '${queryId}' deleted from '${recordSlug}'.`,
+            },
+          ],
+        };
+      } catch (error: unknown) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: formatError(error, `deleting smart query '${queryId}'`),
+            },
+          ],
+          isError: true,
+        };
+      }
+    }
+  );
+
+  server.tool(
+    "test_smart_query",
+    "Test execute a query definition without saving it. Useful for validating query syntax and previewing results before creating a smart query.",
+    {
+      recordSlug: z.string().describe("The structure's record slug to test against"),
+      queryDefinition: z
+        .record(z.string(), z.any())
+        .describe("The query definition to test (where, sort, limit, select, etc.)"),
+      variables: z
+        .record(z.string(), z.string())
+        .optional()
+        .describe("Optional variables to substitute in the query"),
+    },
+    async ({ recordSlug, queryDefinition, variables }) => {
+      try {
+        const input: Record<string, any> = { queryDefinition };
+        if (variables !== undefined) input.variables = variables;
+
+        const result = await sdk.smartQueries.test(recordSlug, input as any);
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(result.data, null, 2) },
+          ],
+        };
+      } catch (error: unknown) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: formatError(error, `test-executing smart query for '${recordSlug}'`),
+            },
+          ],
+          isError: true,
+        };
+      }
+    }
+  );
 }

package/src/tools/structures.ts

@@ -143,4 +143,127 @@ export function registerCollectionTools(server: McpServer, sdk: CentraliSDK) {
       }
     }
   );
+
+  server.tool(
+    "create_collection",
+    "Create a new data collection (schema). Define the name, slug, description, and properties (fields) for the collection.",
+    {
+      name: z.string().describe("Display name for the collection (e.g., 'Customers')"),
+      slug: z.string().describe("URL-safe identifier used in API calls (e.g., 'customers')"),
+      description: z.string().optional().describe("Optional description of the collection"),
+      properties: z
+        .array(z.record(z.string(), z.any()))
+        .optional()
+        .describe("Array of property definitions. Each property has name, type, and optional config (required, unique, defaultValue, description, config)"),
+      enableVersioning: z.boolean().optional().describe("Enable record versioning (default: false)"),
+      schemaDiscoveryMode: z
+        .enum(["strict", "flexible"])
+        .optional()
+        .describe("Schema discovery mode: 'strict' rejects unknown fields, 'flexible' auto-adds them"),
+      tags: z.array(z.string()).optional().describe("Optional tags for organizing collections"),
+    },
+    async ({ name, slug, description, properties, enableVersioning, schemaDiscoveryMode, tags }) => {
+      try {
+        const input: Record<string, any> = { name, slug };
+        if (description !== undefined) input.description = description;
+        if (properties !== undefined) input.properties = properties;
+        if (enableVersioning !== undefined) input.enableVersioning = enableVersioning;
+        if (schemaDiscoveryMode !== undefined) input.schemaDiscoveryMode = schemaDiscoveryMode;
+        if (tags !== undefined) input.tags = tags;
+
+        const result = await sdk.collections.create(input as any);
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(result.data, null, 2) },
+          ],
+        };
+      } catch (error: unknown) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: formatError(error, `creating collection '${slug}'`),
+            },
+          ],
+          isError: true,
+        };
+      }
+    }
+  );
+
+  server.tool(
+    "update_collection",
+    "Update an existing collection by ID. Only include the fields you want to change.",
+    {
+      collectionId: z.string().describe("The collection ID (UUID) to update"),
+      name: z.string().optional().describe("Updated display name"),
+      description: z.string().optional().describe("Updated description"),
+      properties: z
+        .array(z.record(z.string(), z.any()))
+        .optional()
+        .describe("Updated array of property definitions (replaces existing properties)"),
+      enableVersioning: z.boolean().optional().describe("Enable or disable record versioning"),
+      tags: z.array(z.string()).optional().describe("Updated tags"),
+      defaultTtlSeconds: z.number().nullable().optional().describe("Default TTL in seconds for new records. Set to null to clear."),
+    },
+    async ({ collectionId, name, description, properties, enableVersioning, tags, defaultTtlSeconds }) => {
+      try {
+        const input: Record<string, any> = {};
+        if (name !== undefined) input.name = name;
+        if (description !== undefined) input.description = description;
+        if (properties !== undefined) input.properties = properties;
+        if (enableVersioning !== undefined) input.enableVersioning = enableVersioning;
+        if (tags !== undefined) input.tags = tags;
+        if (defaultTtlSeconds !== undefined) input.defaultTtlSeconds = defaultTtlSeconds;
+
+        const result = await sdk.collections.update(collectionId, input as any);
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(result.data, null, 2) },
+          ],
+        };
+      } catch (error: unknown) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: formatError(error, `updating collection '${collectionId}'`),
+            },
+          ],
+          isError: true,
+        };
+      }
+    }
+  );
+
+  server.tool(
+    "delete_collection",
+    "Delete a collection by ID. This permanently removes the collection schema and all its records.",
+    {
+      collectionId: z.string().describe("The collection ID (UUID) to delete"),
+    },
+    async ({ collectionId }) => {
+      try {
+        await sdk.collections.delete(collectionId);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Collection '${collectionId}' deleted successfully.`,
+            },
+          ],
+        };
+      } catch (error: unknown) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: formatError(error, `deleting collection '${collectionId}'`),
+            },
+          ],
+          isError: true,
+        };
+      }
+    }
+  );
 }