@decocms/runtime 1.0.0-alpha.10 → 1.0.0-alpha.11

package/src/bindings/deconfig/types.ts

@@ -1,106 +0,0 @@
-// Types for DeconfigResource
-import { z } from "zod";
-import type { DefaultEnv } from "../../index.ts";
-import type { MCPClientFetchStub, ToolBinder } from "../../mcp.ts";
-import type { BaseResourceDataSchema } from "../resources/bindings.ts";
-
-export type ResourcesBinding<TDataSchema extends BaseResourceDataSchema> =
-  ReturnType<
-    typeof import("../resources/bindings.ts").createResourceBindings<TDataSchema>
-  >;
-
-export type ResourcesTools<TDataSchema extends BaseResourceDataSchema> =
-  ResourcesBinding<TDataSchema>[number]["name"];
-
-export type EnhancedResourcesTools<TDataSchema extends BaseResourceDataSchema> =
-  Partial<
-    Record<
-      ResourcesTools<TDataSchema>,
-      {
-        description: string;
-      }
-    >
-  >;
-
-// Define deconfig tools as ToolBinder array (same pattern as workspaceTools in mcp.ts)
-export const deconfigTools = [
-  {
-    name: "LIST_FILES" as const,
-    inputSchema: z.object({
-      branch: z.string().optional(),
-      prefix: z.string().optional(),
-      select: z.array(z.string()).optional(),
-      includeContent: z.boolean().optional(),
-    }),
-    outputSchema: z.object({
-      files: z.record(
-        z.string(),
-        z.object({
-          address: z.string(),
-          metadata: z.record(z.string(), z.any()),
-          sizeInBytes: z.number(),
-          mtime: z.number(),
-          ctime: z.number(),
-          content: z.string().optional(),
-        }),
-      ),
-      count: z.number(),
-    }),
-  },
-  {
-    name: "READ_FILE" as const,
-    inputSchema: z.object({
-      branch: z.string().optional(),
-      path: z.string(),
-      format: z.enum(["base64", "byteArray", "plainString", "json"]).optional(),
-    }),
-    outputSchema: z.object({
-      content: z.any(),
-      address: z.string(),
-      metadata: z.record(z.any()),
-      mtime: z.number(),
-      ctime: z.number(),
-    }),
-  },
-  {
-    name: "PUT_FILE" as const,
-    inputSchema: z.object({
-      branch: z.string().optional(),
-      path: z.string(),
-      content: z.union([
-        z.string(),
-        z.object({ base64: z.string() }),
-        z.array(z.number()),
-      ]),
-      metadata: z.record(z.any()).optional(),
-      expectedCtime: z.number().optional(),
-    }),
-    outputSchema: z.object({
-      conflict: z.boolean().optional(),
-    }),
-  },
-  {
-    name: "DELETE_FILE" as const,
-    inputSchema: z.object({
-      branch: z.string().optional(),
-      path: z.string(),
-    }),
-    outputSchema: z.object({
-      deleted: z.boolean(),
-    }),
-  },
-] as const satisfies readonly ToolBinder[];
-
-// DeconfigClient is now a typed MCP client stub (same pattern as workspaceTools)
-export type DeconfigClient = MCPClientFetchStub<typeof deconfigTools>;
-
-export interface DeconfigResourceOptions<
-  TDataSchema extends BaseResourceDataSchema,
-> {
-  directory?: string; // defaults to /resources/$resourceName
-  resourceName: string;
-  env: DefaultEnv & { DECONFIG: DeconfigClient };
-  dataSchema: TDataSchema;
-  enhancements?: EnhancedResourcesTools<TDataSchema>;
-  validate?: (data: z.infer<TDataSchema>) => Promise<void>;
-}

package/src/bindings/resources/bindings.ts

@@ -1,99 +0,0 @@
-import { z } from "zod";
-import type { ToolBinder } from "../../mcp.ts";
-import {
-  createCreateInputSchema,
-  createCreateOutputSchema,
-  createItemSchema,
-  createReadOutputSchema,
-  createSearchOutputSchema,
-  createUpdateInputSchema,
-  createUpdateOutputSchema,
-  DeleteInputSchema,
-  DeleteOutputSchema,
-  DescribeInputSchema,
-  DescribeOutputSchema,
-  ReadInputSchema,
-  SearchInputSchema,
-} from "./schemas.ts";
-export type BaseResourceDataSchema = z.ZodObject<{
-  name: z.ZodString;
-  description: z.ZodString;
-}>;
-
-/**
- * Resources 2.0 Bindings
- *
- * This module provides standardized tool bindings for Resources 2.0, a major version upgrade
- * that introduces standardized resource management with `rsc://` URI format and
- * consistent CRUD operations across all resource types.
- *
- * Key Features:
- * - Generic resource bindings that work with any resource type
- * - Standardized tool naming: `deco_resource_*`
- * - Full TypeScript support with proper type constraints
- * - Integration with existing binding system
- */
-
-/**
- * Creates generic resource bindings for Resources 2.0
- *
- * This function generates standardized tool bindings that work with any resource type
- * by accepting a custom data schema and resource name. The bindings provide the standard CRUD operations:
- * - DECO_RESOURCE_{RESOURCE}_SEARCH - Search resources with pagination and filtering
- * - DECO_RESOURCE_{RESOURCE}_READ - Read a single resource by URI
- * - DECO_RESOURCE_{RESOURCE}_CREATE - Create new resources (optional)
- * - DECO_RESOURCE_{RESOURCE}_UPDATE - Update existing resources (optional)
- * - DECO_RESOURCE_{RESOURCE}_DELETE - Delete resources (optional)
- *
- * @param resourceName - The name of the resource type (e.g., "workflow", "document", "user")
- * @param dataSchema - The Zod schema for the resource data type
- * @returns Array of tool bindings for Resources 2.0 CRUD operations
- */
-export function createResourceBindings<
-  TDataSchema extends BaseResourceDataSchema,
->(resourceName: string, dataSchema: TDataSchema) {
-  const readOutputSchema = createReadOutputSchema(dataSchema);
-  return [
-    {
-      name: `DECO_RESOURCE_${resourceName.toUpperCase()}_SEARCH` as const,
-      inputSchema: SearchInputSchema,
-      outputSchema: createSearchOutputSchema(
-        createItemSchema(dataSchema.pick({ name: true, description: true })),
-      ),
-    },
-    {
-      name: `DECO_RESOURCE_${resourceName.toUpperCase()}_READ` as const,
-      inputSchema: ReadInputSchema,
-      outputSchema: readOutputSchema,
-    },
-    {
-      name: `DECO_RESOURCE_${resourceName.toUpperCase()}_CREATE` as const,
-      inputSchema: createCreateInputSchema(dataSchema),
-      outputSchema: createCreateOutputSchema(dataSchema),
-      opt: true,
-    },
-    {
-      name: `DECO_RESOURCE_${resourceName.toUpperCase()}_UPDATE` as const,
-      inputSchema: createUpdateInputSchema(dataSchema),
-      outputSchema: createUpdateOutputSchema(dataSchema),
-      opt: true,
-    },
-    {
-      name: `DECO_RESOURCE_${resourceName.toUpperCase()}_DELETE` as const,
-      inputSchema: DeleteInputSchema,
-      outputSchema: DeleteOutputSchema,
-      opt: true,
-    },
-    {
-      name: `DECO_RESOURCE_${resourceName.toUpperCase()}_DESCRIBE` as const,
-      inputSchema: DescribeInputSchema,
-      outputSchema: DescribeOutputSchema,
-      opt: true,
-    },
-  ] as const satisfies readonly ToolBinder[];
-}
-
-// Export types for TypeScript usage
-export type ResourceBinding<TDataSchema extends BaseResourceDataSchema> =
-  ReturnType<typeof createResourceBindings<TDataSchema>>;
-export type ResourceBindingsFunction = typeof createResourceBindings;

package/src/bindings/resources/helpers.ts

@@ -1,95 +0,0 @@
-import {
-  ResourceUriSchema,
-  type CreateInput,
-  type CreateOutput,
-  type DeleteInput,
-  type DeleteOutput,
-  type ReadInput,
-  type ReadOutput,
-  type SearchInput,
-  type SearchOutput,
-} from "./schemas.ts";
-
-/**
- * Resources 2.0 Helper Functions
- *
- * This module provides helper functions for working with Resources 2.0
- * URI format and validation.
- *
- * Key Features:
- * - URI validation and parsing utilities
- * - URI construction helpers
- * - Type-safe resource URI handling
- */
-
-/**
- * Utility function to validate a resource URI format
- *
- * @param uri - The URI to validate
- * @returns True if the URI is valid, false otherwise
- */
-export function validateResourceUri(uri: string): boolean {
-  try {
-    ResourceUriSchema.parse(uri);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Utility function to parse a resource URI into its components
- *
- * @param uri - The URI to parse
- * @returns Object containing the parsed components or null if invalid
- */
-export function parseResourceUri(uri: string): {
-  workspace: string;
-  project: string;
-  resourceId: string;
-} | null {
-  try {
-    const validated = ResourceUriSchema.parse(uri);
-    const match = validated.match(/^rsc:\/\/([^/]+)\/([^/]+)\/(.+)$/);
-
-    if (!match) {
-      return null;
-    }
-
-    return {
-      workspace: match[1],
-      project: match[2],
-      resourceId: match[3],
-    };
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Utility function to construct a resource URI from components
- *
- * @param workspace - The workspace identifier
- * @param project - The project identifier
- * @param resourceId - The resource identifier
- * @returns The constructed resource URI
- */
-export function constructResourceUri(
-  workspace: string,
-  project: string,
-  resourceId: string,
-): string {
-  return `rsc://${workspace}/${project}/${resourceId}`;
-}
-
-// Re-export types for convenience
-export type {
-  CreateInput,
-  CreateOutput,
-  DeleteInput,
-  DeleteOutput,
-  ReadInput,
-  ReadOutput,
-  SearchInput,
-  SearchOutput,
-};

package/src/bindings/resources/schemas.ts

@@ -1,265 +0,0 @@
-import { z } from "zod";
-
-/**
- * Resources 2.0 Schemas
- *
- * This module provides standardized schemas for Resources 2.0, a major version upgrade
- * that introduces standardized resource management with `rsc://` URI format and
- * consistent CRUD operations across all resource types.
- *
- * Key Features:
- * - Standardized `rsc://` URI format for all resources
- * - Generic CRUD operation schemas that work with any resource type
- * - Type-safe factory functions for creating resource-specific schemas
- * - Comprehensive validation and error handling
- * - Full TypeScript support with Zod validation
- */
-
-// Common URI format validation for Resources 2.0
-export const ResourceUriSchema = z
-  .string()
-  .regex(
-    /^rsc:\/\/[^/]+\/[^/]+\/.+$/,
-    "Invalid resource URI format. Expected format: rsc://workspace/project/resource-id",
-  );
-
-export const DescribeInputSchema = z.object({});
-export const DescribeOutputSchema = z.object({
-  uriTemplate: ResourceUriSchema.describe("URI template for the resource"),
-  features: z.object({
-    watch: z.object({
-      pathname: z.string().describe("Pathname to watch"),
-    }),
-  }),
-});
-
-/**
- * Search input schema for resource queries
- * Supports pagination, filtering, sorting, and search terms
- */
-export const SearchInputSchema = z.object({
-  term: z.string().optional().describe("Search term to filter resources"),
-  page: z.number().int().min(1).default(1).describe("Page number (1-based)"),
-  pageSize: z
-    .number()
-    .int()
-    .min(1)
-    .max(100)
-    .default(20)
-    .describe("Number of items per page"),
-  filters: z.record(z.any()).optional().describe("Additional filters to apply"),
-  sortBy: z.string().optional().describe("Field to sort by"),
-  sortOrder: z
-    .enum(["asc", "desc"])
-    .optional()
-    .default("asc")
-    .describe("Sort order"),
-});
-
-/**
- * Factory function to create search output schema for a specific resource type
- * @param itemSchema - The schema for individual resource items
- * @returns Zod schema for search results with pagination metadata
- */
-export function createSearchOutputSchema<T extends z.ZodTypeAny>(
-  itemSchema: T,
-) {
-  return z.object({
-    items: z.array(itemSchema).describe("Array of matching resources"),
-    totalCount: z
-      .number()
-      .int()
-      .min(0)
-      .describe("Total number of matching resources"),
-    page: z.number().int().min(1).describe("Current page number"),
-    pageSize: z.number().int().min(1).describe("Number of items per page"),
-    totalPages: z.number().int().min(0).describe("Total number of pages"),
-    hasNextPage: z.boolean().describe("Whether there are more pages available"),
-    hasPreviousPage: z
-      .boolean()
-      .describe("Whether there are previous pages available"),
-  });
-}
-
-/**
- * Read input schema for retrieving a single resource
- */
-export const ReadInputSchema = z.object({
-  uri: ResourceUriSchema.describe("URI of the resource to read"),
-});
-
-/**
- * Factory function to create read output schema for a specific resource type
- * @param dataSchema - The schema for the resource data
- * @returns Zod schema for read operation results
- */
-export function createReadOutputSchema<T extends z.ZodTypeAny>(dataSchema: T) {
-  return z.object({
-    uri: ResourceUriSchema.describe("URI of the resource"),
-    data: dataSchema.describe("Resource data"),
-    created_at: z.string().datetime().optional().describe("Creation timestamp"),
-    updated_at: z
-      .string()
-      .datetime()
-      .optional()
-      .describe("Last update timestamp"),
-    created_by: z.string().optional().describe("User who created the resource"),
-    updated_by: z
-      .string()
-      .optional()
-      .describe("User who last updated the resource"),
-  });
-}
-
-/**
- * Factory function to create create input schema for a specific resource type
- * @param dataSchema - The schema for the resource data to create
- * @returns Zod schema for create operation input
- */
-export function createCreateInputSchema<T extends z.ZodTypeAny>(dataSchema: T) {
-  return z.object({
-    data: dataSchema.describe("Resource data to create"),
-  });
-}
-
-/**
- * Factory function to create create output schema for a specific resource type
- * @param dataSchema - The schema for the created resource data
- * @returns Zod schema for create operation results
- */
-export function createCreateOutputSchema<T extends z.ZodTypeAny>(
-  dataSchema: T,
-) {
-  return z.object({
-    uri: ResourceUriSchema.describe("URI of the created resource"),
-    data: dataSchema.describe("Created resource data"),
-    created_at: z.string().datetime().optional().describe("Creation timestamp"),
-    updated_at: z
-      .string()
-      .datetime()
-      .optional()
-      .describe("Last update timestamp"),
-    created_by: z.string().optional().describe("User who created the resource"),
-  });
-}
-
-/**
- * Factory function to create update input schema for a specific resource type
- * @param dataSchema - The schema for the resource data to update
- * @returns Zod schema for update operation input
- */
-export function createUpdateInputSchema<T extends z.ZodTypeAny>(dataSchema: T) {
-  return z.object({
-    uri: ResourceUriSchema.describe("URI of the resource to update"),
-    data: dataSchema.describe("Updated resource data"),
-  });
-}
-
-/**
- * Factory function to create update output schema for a specific resource type
- * @param dataSchema - The schema for the updated resource data
- * @returns Zod schema for update operation results
- */
-export function createUpdateOutputSchema<T extends z.ZodTypeAny>(
-  dataSchema: T,
-) {
-  return z.object({
-    uri: ResourceUriSchema.describe("URI of the updated resource"),
-    data: dataSchema.describe("Updated resource data"),
-    created_at: z
-      .string()
-      .datetime()
-      .optional()
-      .describe("Original creation timestamp"),
-    updated_at: z
-      .string()
-      .datetime()
-      .optional()
-      .describe("Last update timestamp"),
-    created_by: z
-      .string()
-      .optional()
-      .describe("User who originally created the resource"),
-    updated_by: z
-      .string()
-      .optional()
-      .describe("User who last updated the resource"),
-  });
-}
-
-/**
- * Delete input schema for removing a resource
- */
-export const DeleteInputSchema = z.object({
-  uri: ResourceUriSchema.describe("URI of the resource to delete"),
-});
-
-/**
- * Delete output schema for delete operation results
- */
-export const DeleteOutputSchema = z.object({
-  success: z.boolean().describe("Whether the deletion was successful"),
-  uri: ResourceUriSchema.describe("URI of the deleted resource"),
-});
-
-/**
- * Factory function to create item schema for a specific resource type
- * This schema is used in search results and lists
- * @param dataSchema - The schema for the resource data
- * @returns Zod schema for resource items with metadata
- */
-export function createItemSchema<T extends z.ZodTypeAny>(dataSchema: T) {
-  return z.object({
-    uri: ResourceUriSchema.describe("URI of the resource"),
-    data: z
-      .object({
-        name: z.string().min(1, "Name is required"),
-        description: z
-          .string()
-          .optional()
-          .describe("Description of the resource"),
-        icon: z.string().url().optional().describe("URL to the resource icon"),
-      })
-      .and(dataSchema)
-      .describe("Resource data with required name"),
-    created_at: z.string().datetime().optional().describe("Creation timestamp"),
-    updated_at: z
-      .string()
-      .datetime()
-      .optional()
-      .describe("Last update timestamp"),
-    created_by: z.string().optional().describe("User who created the resource"),
-    updated_by: z
-      .string()
-      .optional()
-      .describe("User who last updated the resource"),
-  });
-}
-
-// Export types for TypeScript usage
-export type ResourceUri = z.infer<typeof ResourceUriSchema>;
-export type SearchInput = z.infer<typeof SearchInputSchema>;
-export type SearchOutput<T extends z.ZodTypeAny> = z.infer<
-  ReturnType<typeof createSearchOutputSchema<T>>
->;
-export type ReadInput = z.infer<typeof ReadInputSchema>;
-export type ReadOutput<T extends z.ZodTypeAny> = z.infer<
-  ReturnType<typeof createReadOutputSchema<T>>
->;
-export type CreateInput<T extends z.ZodTypeAny> = z.infer<
-  ReturnType<typeof createCreateInputSchema<T>>
->;
-export type CreateOutput<T extends z.ZodTypeAny> = z.infer<
-  ReturnType<typeof createCreateOutputSchema<T>>
->;
-export type UpdateInput<T extends z.ZodTypeAny> = z.infer<
-  ReturnType<typeof createUpdateInputSchema<T>>
->;
-export type UpdateOutput<T extends z.ZodTypeAny> = z.infer<
-  ReturnType<typeof createUpdateOutputSchema<T>>
->;
-export type DeleteInput = z.infer<typeof DeleteInputSchema>;
-export type DeleteOutput = z.infer<typeof DeleteOutputSchema>;
-export type ResourceItem<T extends z.ZodTypeAny> = z.infer<
-  ReturnType<typeof createItemSchema<T>>
->;

package/src/bindings/views.ts

@@ -1,14 +0,0 @@
-import { ViewsListOutputSchema } from "../views.ts";
-import { z } from "zod";
-import type { ToolBinder } from "../mcp.ts";
-
-export const VIEW_BINDING = [
-  {
-    name: "DECO_CHAT_VIEWS_LIST" as const,
-    inputSchema: z.any(),
-    outputSchema: ViewsListOutputSchema,
-  },
-] as const satisfies readonly ToolBinder[];
-
-// Re-export for existing imports expecting listViewsSchema
-export const listViewsSchema = ViewsListOutputSchema;