feat: exclude node-only providers from Cloudflare (#88)

Author: l1shen

.gitignore

@@ -6,7 +6,7 @@ node_modules/
 dist/
 coverage/
 catalog/
-src/providers/registry.generated.ts
+src/providers/registry*.generated.ts
 .env
 .env.*
 !.env.example

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@oomol-lab/open-connector",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "private": true,
   "workspaces": [
     "web"

package.json

@@ -3,19 +3,24 @@ import { readdir, stat } from "node:fs/promises";
 import { join } from "node:path";
 
 const rootDir = process.cwd();
-const registryPath = join(process.cwd(), "src/providers/registry.generated.ts");
+const registryPaths = [
+  join(process.cwd(), "src/providers/registry.generated.ts"),
+  join(process.cwd(), "src/providers/registry.cloudflare.generated.ts"),
+];
 const catalogDir = join(process.cwd(), "catalog/apps");
 const sourcePaths = [
   join(rootDir, "src/core"),
   join(rootDir, "src/providers"),
   join(rootDir, "scripts/generate-catalog.ts"),
   join(rootDir, "scripts/generate-provider-registry.ts"),
+  join(rootDir, "scripts/provider-source.ts"),
 ];
-const generatedPaths = new Set([registryPath]);
+const generatedPaths = new Set(registryPaths);
 
 const sourceMtimeMs = await newestMtimeMs(sourcePaths);
 
-if (!(await isFreshFile(registryPath, sourceMtimeMs))) {
+const registriesFresh = await Promise.all(registryPaths.map((path) => isFreshFile(path, sourceMtimeMs)));
+if (registriesFresh.some((fresh) => !fresh)) {
   runNodeScript("scripts/generate-provider-registry.ts");
 }
 

scripts/ensure-generated.ts

@@ -1,56 +1,61 @@
+import type { ProviderSource } from "./provider-source.ts";
+
 import { readFile, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { loadProviderSources } from "./provider-source.ts";
 
 const providersDir = join(process.cwd(), "src/providers");
 const providerSources = await loadProviderSources();
-const services = providerSources.map((source) => source.service);
-const executableActionIds = new Map<string, string[]>(
-  providerSources.map((source) => [
-    source.service,
-    source.definition.actions.map((action) => action.id).sort((a, b) => a.localeCompare(b)),
-  ]),
-);
+
+await Promise.all([
+  writeRegistry("registry.generated.ts", providerSources),
+  writeRegistry(
+    "registry.cloudflare.generated.ts",
+    providerSources.filter((source) => !source.nodeOnly),
+  ),
+]);
 
 function propertyName(service: string): string {
   return /^[A-Za-z_$][\w$]*$/.test(service) ? service : JSON.stringify(service);
 }
 
-const registryLines = [
-  'import type { CredentialValidators, ProviderExecutors, ProviderProxyExecutor } from "../core/types.ts";',
-  "",
-  "/** Lazy-loaded provider executor module shape. */",
-  "export type ExecutorModule = {",
-  "  credentialValidators?: CredentialValidators;",
-  "  executors: ProviderExecutors;",
-  "  proxy?: ProviderProxyExecutor;",
-  "};",
-  "",
-  "/** Generated lazy imports for provider executors. Do not hand-edit. */",
-  "export const executorModules: Record<string, () => Promise<ExecutorModule>> = {",
-  ...services.map(
-    (service) => `  ${propertyName(service)}: (): Promise<ExecutorModule> => import("./${service}/executors.ts"),`,
-  ),
-  "};",
-  "",
-  "/** Generated local executable action ids by provider. Do not hand-edit. */",
-  "export const executableActionIds: Record<string, string[]> = {",
-  ...services.flatMap((service) => [
-    `  ${propertyName(service)}: [`,
-    ...(executableActionIds.get(service) ?? []).map((actionId) => `    ${JSON.stringify(actionId)},`),
-    "  ],",
-  ]),
-  "};",
-];
+async function writeRegistry(filename: string, sources: ProviderSource[]): Promise<void> {
+  const services = sources.map((source) => source.service);
+  const executableActionIds = new Map<string, string[]>(
+    sources.map((source) => [
+      source.service,
+      source.definition.actions.map((action) => action.id).sort((a, b) => a.localeCompare(b)),
+    ]),
+  );
+  const lines = [
+    'import type { ExecutorModule } from "./provider-loader.ts";',
+    "",
+    "/** Generated lazy imports for provider executors. Do not hand-edit. */",
+    "export const executorModules: Record<string, () => Promise<ExecutorModule>> = {",
+    ...services.map(
+      (service) => `  ${propertyName(service)}: (): Promise<ExecutorModule> => import("./${service}/executors.ts"),`,
+    ),
+    "};",
+    "",
+    "/** Generated local executable action ids by provider. Do not hand-edit. */",
+    "export const executableActionIds: Record<string, string[]> = {",
+    ...services.flatMap((service) => [
+      `  ${propertyName(service)}: [`,
+      ...(executableActionIds.get(service) ?? []).map((actionId) => `    ${JSON.stringify(actionId)},`),
+      "  ],",
+    ]),
+    "};",
+  ];
 
-const registryPath = join(providersDir, "registry.generated.ts");
-const registryContent = `${registryLines.join("\n")}\n`;
-const existingContent = await readTextFile(registryPath);
-if (existingContent !== registryContent) {
-  await writeFile(registryPath, registryContent);
-  console.log(`Generated provider registry for ${services.length} providers.`);
-} else {
-  console.log(`Provider registry is up to date for ${services.length} providers.`);
+  const path = join(providersDir, filename);
+  const content = `${lines.join("\n")}\n`;
+  const existingContent = await readTextFile(path);
+  if (existingContent !== content) {
+    await writeFile(path, content);
+    console.log(`Generated ${filename} for ${services.length} providers.`);
+  } else {
+    console.log(`${filename} is up to date for ${services.length} providers.`);
+  }
 }
 
 async function readTextFile(path: string): Promise<string | undefined> {

scripts/generate-provider-registry.ts

@@ -6,6 +6,7 @@ import { assertProviderId } from "../src/core/provider-id.ts";
 
 export interface ProviderSource {
   definition: ProviderDefinition;
+  nodeOnly: boolean;
   service: string;
 }
 
@@ -23,13 +24,15 @@ export async function loadProviderSources(): Promise<ProviderSource[]> {
       assertProviderDefinitionService(service, module.provider.service);
       return {
         definition: module.provider,
+        nodeOnly: module.nodeOnly === true,
         service,
       };
     }),
   );
 }
 
 interface ProviderDefinitionModule {
+  nodeOnly?: boolean;
   provider: ProviderDefinition;
 }
 

scripts/provider-source.ts

@@ -70,6 +70,24 @@ const customCredentialProvider: ProviderDefinition = {
   actions: [],
 };
 
+const catalogOnlyProvider: ProviderDefinition = {
+  ...customCredentialProvider,
+  service: "catalog_only",
+  displayName: "Catalog Only",
+  actions: [
+    {
+      id: "catalog_only.query",
+      service: "catalog_only",
+      name: "query",
+      description: "Query the catalog-only provider.",
+      requiredScopes: [],
+      providerPermissions: [],
+      inputSchema: {},
+      outputSchema: {},
+    },
+  ],
+};
+
 const oauthProvider: ProviderDefinition = {
   service: "example",
   displayName: "Example",
@@ -113,6 +131,24 @@ afterEach(() => {
 });
 
 describe("ConnectionService", () => {
+  it("rejects connections for providers unavailable in the current runtime", async () => {
+    const service = createService([catalogOnlyProvider]);
+
+    await expect(
+      service.connectWithCustomCredential("catalog_only", {
+        values: {
+          host: "localhost",
+          password: "secret",
+        },
+      }),
+    ).rejects.toMatchObject({
+      code: "provider_unavailable",
+      message: "Catalog Only is not available in this runtime.",
+    });
+
+    await expect(service.listConnections()).resolves.toEqual([]);
+  });
+
   it("exposes no_auth providers as virtual connections", async () => {
     const service = createService([hackernewsProvider]);
 

src/connection-service.test.ts

@@ -1,4 +1,4 @@
-import type { CatalogStore } from "./catalog-store.ts";
+import type { CatalogStore, RuntimeProviderDefinition } from "./catalog-store.ts";
 import type {
   ApiKeyAuthDefinition,
   AuthType,
@@ -207,7 +207,7 @@ export class ConnectionService {
   }
 
   async connectWithoutAuth(service: string, input: ConnectWithoutAuthInput = {}): Promise<ConnectionSummary> {
-    const provider = this.getProvider(service);
+    const provider = this.getAvailableProvider(service);
     if (!this.supportsAuth(provider, "no_auth")) {
       throw new ConnectionError("unsupported_auth_type", `${service} does not support no_auth.`);
     }
@@ -216,7 +216,7 @@ export class ConnectionService {
   }
 
   async connectWithApiKey(service: string, input: ConnectWithCredentialInput): Promise<ConnectionSummary> {
-    const provider = this.getProvider(service);
+    const provider = this.getAvailableProvider(service);
     if (!this.supportsAuth(provider, "api_key")) {
       throw new ConnectionError("unsupported_auth_type", `${service} does not support api_key.`);
     }
@@ -248,7 +248,7 @@ export class ConnectionService {
   }
 
   async connectWithCustomCredential(service: string, input: ConnectWithCredentialInput): Promise<ConnectionSummary> {
-    const provider = this.getProvider(service);
+    const provider = this.getAvailableProvider(service);
     if (!this.supportsAuth(provider, "custom_credential")) {
       throw new ConnectionError("unsupported_auth_type", `${service} does not support custom_credential.`);
     }
@@ -281,7 +281,7 @@ export class ConnectionService {
     credential: Extract<ResolvedCredential, { authType: "oauth2" }>,
     connectionNameInput?: string,
   ): Promise<ConnectionSummary> {
-    const provider = this.getProvider(service);
+    const provider = this.getAvailableProvider(service);
     if (!this.supportsAuth(provider, "oauth2")) {
       throw new ConnectionError("unsupported_auth_type", `${service} does not support oauth2.`);
     }
@@ -357,7 +357,12 @@ export class ConnectionService {
     };
   }
 
-  private getProvider(service: string): ProviderDefinition {
+  /** Rejects provider setup when none of its catalog actions can execute in this runtime. */
+  assertProviderAvailable(service: string): void {
+    this.getAvailableProvider(service);
+  }
+
+  private getProvider(service: string): RuntimeProviderDefinition {
     const provider = this.catalog.providers.find((provider) => provider.service === service);
     if (!provider) {
       throw new ConnectionError("unknown_service", `Unknown service: ${service}.`);
@@ -366,6 +371,15 @@ export class ConnectionService {
     return provider;
   }
 
+  private getAvailableProvider(service: string): RuntimeProviderDefinition {
+    const provider = this.getProvider(service);
+    if (provider.actions.length > 0 && provider.execution.locallyExecutableActionCount === 0) {
+      throw new ConnectionError("provider_unavailable", `${provider.displayName} is not available in this runtime.`);
+    }
+
+    return provider;
+  }
+
   private supportsAuth(provider: ProviderDefinition, authType: AuthType): boolean {
     return provider.authTypes.includes(authType);
   }

src/connection-service.ts

@@ -64,6 +64,7 @@ export class OAuthFlowService {
 
   async startAuthorization(input: OAuthAuthorizationStartInput): Promise<OAuthAuthorizationStart> {
     const { service, connectionName } = input;
+    this.connections.assertProviderAvailable(service);
     const auth = this.clientConfigs.getOAuthDefinition(service);
     const config = await this.clientConfigs.getConfig(service);
     if (!config) {

src/oauth/oauth-flow-service.ts

@@ -2,6 +2,8 @@ import type { ProviderDefinition } from "../../core/types.ts";
 
 import { neteaseMailActions } from "./actions.ts";
 
+export const nodeOnly = true;
+
 export const provider: ProviderDefinition = {
   service: "netease_mail",
   displayName: "NetEase Mail",