@rashidazarang/airtable-mcp 3.1.0 → 3.2.5

package/types/typescript/app/airtable-client.d.ts

@@ -0,0 +1,49 @@
+import { RateLimiter } from './rateLimiter';
+import { Logger } from './logger';
+interface RequestOptions {
+    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    /**
+     * Path including leading slash and version segment, e.g. `/v0/meta/bases/app123`.
+     */
+    path: string;
+    query?: Record<string, string | number | boolean | Array<string | number | boolean> | undefined>;
+    body?: unknown;
+    baseId?: string;
+    idempotencyKey?: string;
+}
+interface ClientOptions {
+    baseLimiter: RateLimiter;
+    patLimiter: RateLimiter;
+    logger: Logger;
+    userAgent: string;
+    patHash: string;
+    maxRetries?: number;
+}
+export declare class AirtableClient {
+    private readonly baseLimiter;
+    private readonly patLimiter;
+    private readonly logger;
+    private readonly userAgent;
+    private readonly pat;
+    private readonly patHash;
+    private readonly maxRetries;
+    constructor(personalAccessToken: string, options: ClientOptions);
+    listBases(): Promise<{
+        bases: unknown[];
+    }>;
+    getBase(baseId: string): Promise<unknown>;
+    listTables(baseId: string): Promise<{
+        tables: unknown[];
+    }>;
+    queryRecords<T = unknown>(baseId: string, table: string, query?: RequestOptions['query']): Promise<T>;
+    createRecords<T = unknown>(baseId: string, table: string, payload: unknown, idempotencyKey?: string): Promise<T>;
+    updateRecords<T = unknown>(baseId: string, table: string, payload: unknown, idempotencyKey?: string): Promise<T>;
+    upsertRecords<T = unknown>(baseId: string, table: string, payload: unknown, idempotencyKey?: string): Promise<T>;
+    private request;
+    private withRetry;
+    private backoffWithJitter;
+    private performRequest;
+    private toDomainError;
+    private safeExtractErrorType;
+}
+export {};

package/types/typescript/app/config.d.ts

@@ -0,0 +1,16 @@
+import { GovernanceSnapshot } from './types';
+export type LogLevel = 'error' | 'warn' | 'info' | 'debug';
+export interface AirtableAuthConfig {
+    personalAccessToken: string;
+    patHash: string;
+    defaultBaseId?: string;
+    allowedBases: string[];
+}
+export interface AppConfig {
+    version: string;
+    auth: AirtableAuthConfig;
+    governance: GovernanceSnapshot;
+    logLevel: LogLevel;
+    exceptionQueueSize: number;
+}
+export declare function loadConfig(): AppConfig;

package/types/typescript/app/context.d.ts

@@ -0,0 +1,12 @@
+import { AppConfig } from './config';
+import { AirtableClient } from './airtable-client';
+import { GovernanceService } from './governance';
+import { ExceptionStore } from './exceptions';
+import { Logger } from './logger';
+export interface AppContext {
+    config: AppConfig;
+    logger: Logger;
+    airtable: AirtableClient;
+    governance: GovernanceService;
+    exceptions: ExceptionStore;
+}

package/types/typescript/app/exceptions.d.ts

@@ -0,0 +1,12 @@
+import { Logger } from './logger';
+import { ListExceptionsInput, ListExceptionsOutput } from './types';
+import { AirtableBrainError } from '../errors';
+export declare class ExceptionStore {
+    private readonly capacity;
+    private readonly items;
+    private readonly logger;
+    constructor(capacity: number, logger: Logger);
+    record(error: AirtableBrainError, summary: string, details?: string, proposedFix?: Record<string, unknown>): void;
+    list(params: ListExceptionsInput): ListExceptionsOutput;
+    private parseCursor;
+}

package/types/typescript/app/governance.d.ts

@@ -0,0 +1,18 @@
+import { GovernanceSnapshot } from './types';
+type Operation = GovernanceSnapshot['allowedOperations'][number];
+export declare class GovernanceService {
+    private readonly snapshot;
+    private readonly tablesByBase;
+    constructor(snapshot: GovernanceSnapshot);
+    ensureBaseAllowed(baseId: string): void;
+    ensureOperationAllowed(operation: Operation): void;
+    ensureTableAllowed(baseId: string, table: string): void;
+    listPiiPolicies(baseId: string, table: string): Array<{
+        field: string;
+        policy: string;
+    }>;
+    getSnapshot(): GovernanceSnapshot;
+    isTableAllowed(baseId: string, table: string): boolean;
+    private buildTableIndex;
+}
+export {};

package/types/typescript/app/logger.d.ts

@@ -0,0 +1,13 @@
+import { LogLevel } from './config';
+export type LogMetadata = Record<string, unknown>;
+export declare class Logger {
+    private readonly level;
+    private readonly context;
+    constructor(level: LogLevel, context?: LogMetadata);
+    child(context: LogMetadata): Logger;
+    error(message: string, metadata?: LogMetadata): void;
+    warn(message: string, metadata?: LogMetadata): void;
+    info(message: string, metadata?: LogMetadata): void;
+    debug(message: string, metadata?: LogMetadata): void;
+    private log;
+}

package/types/typescript/app/rateLimiter.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Lightweight token-based rate limiter to enforce Airtable quotas.
+ * Maintains per-key queues to preserve ordering and fairness.
+ */
+export declare class RateLimiter {
+    private readonly minIntervalMs;
+    private readonly lockByKey;
+    private readonly nextAvailableByKey;
+    constructor({ maxRequestsPerSecond }: {
+        maxRequestsPerSecond: number;
+    });
+    schedule(key: string): Promise<void>;
+}

package/types/typescript/app/tools/create.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp';
+import { AppContext } from '../context';
+export declare function registerCreateTool(server: McpServer, ctx: AppContext): void;

package/types/typescript/app/tools/describe.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp';
+import { AppContext } from '../context';
+export declare function registerDescribeTool(server: McpServer, ctx: AppContext): void;

package/types/typescript/app/tools/handleError.d.ts

@@ -0,0 +1,8 @@
+import { AppContext } from '../context';
+export declare function handleToolError(toolName: string, error: unknown, ctx: AppContext): {
+    isError: boolean;
+    content: {
+        type: "text";
+        text: string;
+    }[];
+};

package/types/typescript/app/tools/index.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp';
+import { AppContext } from '../context';
+export declare function registerAllTools(server: McpServer, ctx: AppContext): void;

package/types/typescript/app/tools/listBases.d.ts

@@ -0,0 +1,33 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp';
+import { AppContext } from '../context';
+import { z } from 'zod';
+declare const listBasesOutputSchema: z.ZodObject<{
+    bases: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        permissionLevel: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        name: string;
+        permissionLevel?: string | undefined;
+    }, {
+        id: string;
+        name: string;
+        permissionLevel?: string | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    bases: {
+        id: string;
+        name: string;
+        permissionLevel?: string | undefined;
+    }[];
+}, {
+    bases: {
+        id: string;
+        name: string;
+        permissionLevel?: string | undefined;
+    }[];
+}>;
+export type ListBasesOutput = z.infer<typeof listBasesOutputSchema>;
+export declare function registerListBasesTool(server: McpServer, ctx: AppContext): void;
+export {};

package/types/typescript/app/tools/listExceptions.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp';
+import { AppContext } from '../context';
+export declare function registerExceptionsTool(server: McpServer, ctx: AppContext): void;

package/types/typescript/app/tools/listGovernance.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp';
+import { AppContext } from '../context';
+export declare function registerGovernanceTool(server: McpServer, ctx: AppContext): void;

package/types/typescript/app/tools/query.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp';
+import { AppContext } from '../context';
+export declare function registerQueryTool(server: McpServer, ctx: AppContext): void;

package/types/typescript/app/tools/update.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp';
+import { AppContext } from '../context';
+export declare function registerUpdateTool(server: McpServer, ctx: AppContext): void;

package/types/typescript/app/tools/upsert.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp';
+import { AppContext } from '../context';
+export declare function registerUpsertTool(server: McpServer, ctx: AppContext): void;

package/types/typescript/app/tools/webhooks.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp';
+import { AppContext } from '../context';
+export declare function registerWebhookTools(server: McpServer, ctx: AppContext): void;