@tinybirdco/sdk 0.0.49 → 0.0.51

package/src/generator/connection.test.ts

@@ -1,6 +1,10 @@
 import { describe, it, expect } from "vitest";
 import { generateConnection, generateAllConnections } from "./connection.js";
-import { defineKafkaConnection, defineS3Connection } from "../schema/connection.js";
+import {
+  defineKafkaConnection,
+  defineS3Connection,
+  defineGCSConnection,
+} from "../schema/connection.js";
 
 describe("Connection Generator", () => {
   describe("generateConnection", () => {
@@ -152,6 +156,20 @@ describe("Connection Generator", () => {
       expect(result.content).toContain('S3_ACCESS_KEY {{ tb_secret("S3_ACCESS_KEY") }}');
       expect(result.content).toContain('S3_SECRET {{ tb_secret("S3_SECRET") }}');
     });
+
+    it("generates GCS connection with service account credentials", () => {
+      const conn = defineGCSConnection("my_gcs", {
+        serviceAccountCredentialsJson: '{{ tb_secret("GCS_SERVICE_ACCOUNT_CREDENTIALS_JSON") }}',
+      });
+
+      const result = generateConnection(conn);
+
+      expect(result.name).toBe("my_gcs");
+      expect(result.content).toContain("TYPE gcs");
+      expect(result.content).toContain(
+        'GCS_SERVICE_ACCOUNT_CREDENTIALS_JSON {{ tb_secret("GCS_SERVICE_ACCOUNT_CREDENTIALS_JSON") }}'
+      );
+    });
   });
 
   describe("generateAllConnections", () => {
@@ -163,11 +181,18 @@ describe("Connection Generator", () => {
         region: "us-east-1",
         arn: "arn:aws:iam::123456789012:role/tinybird-s3-access",
       });
+      const conn3 = defineGCSConnection("gcs_landing", {
+        serviceAccountCredentialsJson: '{{ tb_secret("GCS_SERVICE_ACCOUNT_CREDENTIALS_JSON") }}',
+      });
 
-      const results = generateAllConnections({ kafka1: conn1, s3_logs: conn2 });
+      const results = generateAllConnections({
+        kafka1: conn1,
+        s3_logs: conn2,
+        gcs_landing: conn3,
+      });
 
-      expect(results).toHaveLength(2);
-      expect(results.map((r) => r.name).sort()).toEqual(["kafka1", "s3_logs"]);
+      expect(results).toHaveLength(3);
+      expect(results.map((r) => r.name).sort()).toEqual(["gcs_landing", "kafka1", "s3_logs"]);
     });
 
     it("returns empty array for empty connections", () => {

package/src/generator/connection.ts

@@ -3,8 +3,16 @@
  * Converts ConnectionDefinition to native .connection file format
  */
 
-import type { ConnectionDefinition, KafkaConnectionDefinition } from "../schema/connection.js";
-import { isS3ConnectionDefinition, type S3ConnectionDefinition } from "../schema/connection.js";
+import type {
+  ConnectionDefinition,
+  KafkaConnectionDefinition,
+  GCSConnectionDefinition,
+} from "../schema/connection.js";
+import {
+  isS3ConnectionDefinition,
+  isGCSConnectionDefinition,
+  type S3ConnectionDefinition,
+} from "../schema/connection.js";
 
 /**
  * Generated connection content
@@ -78,6 +86,19 @@ function generateS3Connection(connection: S3ConnectionDefinition): string {
   return parts.join("\n");
 }
 
+/**
+ * Generate a GCS connection content
+ */
+function generateGCSConnection(connection: GCSConnectionDefinition): string {
+  const parts: string[] = [];
+  const options = connection.options;
+
+  parts.push("TYPE gcs");
+  parts.push(`GCS_SERVICE_ACCOUNT_CREDENTIALS_JSON ${options.serviceAccountCredentialsJson}`);
+
+  return parts.join("\n");
+}
+
 /**
  * Generate a .connection file content from a ConnectionDefinition
  *
@@ -113,6 +134,8 @@ export function generateConnection(
     content = generateKafkaConnection(connection as KafkaConnectionDefinition);
   } else if (isS3ConnectionDefinition(connection)) {
     content = generateS3Connection(connection);
+  } else if (isGCSConnectionDefinition(connection)) {
+    content = generateGCSConnection(connection);
   } else {
     throw new Error("Unsupported connection type.");
   }

package/src/generator/datasource.test.ts

@@ -1,7 +1,7 @@
 import { describe, it, expect } from 'vitest';
 import { generateDatasource, generateAllDatasources } from './datasource.js';
 import { defineDatasource } from '../schema/datasource.js';
-import { defineKafkaConnection, defineS3Connection } from '../schema/connection.js';
+import { defineKafkaConnection, defineS3Connection, defineGCSConnection } from '../schema/connection.js';
 import { defineToken } from '../schema/token.js';
 import { t } from '../schema/types.js';
 import { engine } from '../schema/engines.js';
@@ -95,6 +95,28 @@ describe('Datasource Generator', () => {
       expect(result.content).toContain('FORWARD_QUERY >');
       expect(result.content).toContain('    SELECT id');
     });
+
+    it("includes indexes block when provided", () => {
+      const ds = defineDatasource("test_ds", {
+        schema: {
+          id: t.string(),
+          pipe_name: t.string(),
+        },
+        indexes: [
+          { name: "pipe_name_set", expr: "pipe_name", type: "set(100)", granularity: 1 },
+          { name: "id_bf", expr: "lower(id)", type: "bloom_filter(0.001)", granularity: 4 },
+        ],
+      });
+
+      const result = generateDatasource(ds);
+      expect(result.content).toContain("INDEXES >");
+      expect(result.content).toContain(
+        "pipe_name_set pipe_name TYPE set(100) GRANULARITY 1"
+      );
+      expect(result.content).toContain(
+        "id_bf lower(id) TYPE bloom_filter(0.001) GRANULARITY 4"
+      );
+    });
   });
 
   describe('Column formatting', () => {
@@ -529,6 +551,35 @@ describe('Datasource Generator', () => {
     });
   });
 
+  describe('GCS configuration', () => {
+    it('includes GCS import directives', () => {
+      const gcsConn = defineGCSConnection('my_gcs', {
+        serviceAccountCredentialsJson: '{{ tb_secret("GCS_SERVICE_ACCOUNT_CREDENTIALS_JSON") }}',
+      });
+
+      const ds = defineDatasource('gcs_events', {
+        schema: {
+          timestamp: t.dateTime(),
+          event: t.string(),
+        },
+        engine: engine.mergeTree({ sortingKey: ['timestamp'] }),
+        gcs: {
+          connection: gcsConn,
+          bucketUri: 'gs://my-bucket/events/*.csv',
+          schedule: '@auto',
+          fromTimestamp: '2024-01-01T00:00:00Z',
+        },
+      });
+
+      const result = generateDatasource(ds);
+
+      expect(result.content).toContain('IMPORT_CONNECTION_NAME my_gcs');
+      expect(result.content).toContain('IMPORT_BUCKET_URI gs://my-bucket/events/*.csv');
+      expect(result.content).toContain('IMPORT_SCHEDULE @auto');
+      expect(result.content).toContain('IMPORT_FROM_TIMESTAMP 2024-01-01T00:00:00Z');
+    });
+  });
+
   describe('Token generation', () => {
     it('generates TOKEN lines with inline config', () => {
       const ds = defineDatasource('test_ds', {

package/src/generator/datasource.ts

@@ -9,7 +9,9 @@ import type {
   ColumnDefinition,
   KafkaConfig,
   S3Config,
+  GCSConfig,
   TokenConfig,
+  DatasourceIndex,
 } from "../schema/datasource.js";
 import type { AnyTypeValidator, TypeModifiers } from "../schema/types.js";
 import { getColumnType, getColumnJsonPath } from "../schema/datasource.js";
@@ -176,18 +178,18 @@ function generateKafkaConfig(kafka: KafkaConfig): string {
 /**
  * Generate S3 import configuration lines
  */
-function generateS3Config(s3: S3Config): string {
+function generateImportConfig(importConfig: S3Config | GCSConfig): string {
   const parts: string[] = [];
 
-  parts.push(`IMPORT_CONNECTION_NAME ${s3.connection._name}`);
-  parts.push(`IMPORT_BUCKET_URI ${s3.bucketUri}`);
+  parts.push(`IMPORT_CONNECTION_NAME ${importConfig.connection._name}`);
+  parts.push(`IMPORT_BUCKET_URI ${importConfig.bucketUri}`);
 
-  if (s3.schedule) {
-    parts.push(`IMPORT_SCHEDULE ${s3.schedule}`);
+  if (importConfig.schedule) {
+    parts.push(`IMPORT_SCHEDULE ${importConfig.schedule}`);
   }
 
-  if (s3.fromTimestamp) {
-    parts.push(`IMPORT_FROM_TIMESTAMP ${s3.fromTimestamp}`);
+  if (importConfig.fromTimestamp) {
+    parts.push(`IMPORT_FROM_TIMESTAMP ${importConfig.fromTimestamp}`);
   }
 
   return parts.join("\n");
@@ -210,6 +212,23 @@ function generateForwardQuery(forwardQuery?: string): string | null {
   return ["FORWARD_QUERY >", ...lines.map((line) => `    ${line}`)].join("\n");
 }
 
+/**
+ * Generate INDEXES section
+ */
+function generateIndexes(indexes?: readonly DatasourceIndex[]): string | null {
+  if (!indexes || indexes.length === 0) {
+    return null;
+  }
+
+  const lines = ["INDEXES >"];
+  for (const index of indexes) {
+    lines.push(
+      `    ${index.name} ${index.expr} TYPE ${index.type} GRANULARITY ${index.granularity}`
+    );
+  }
+  return lines.join("\n");
+}
+
 /**
  * Generate SHARED_WITH section for sharing datasource with other workspaces
  */
@@ -291,8 +310,13 @@ export function generateDatasource(
 ): GeneratedDatasource {
   const parts: string[] = [];
 
-  if (datasource.options.kafka && datasource.options.s3) {
-    throw new Error("Datasource cannot define both `kafka` and `s3` ingestion options.");
+  const ingestionConfigCount = [
+    datasource.options.kafka,
+    datasource.options.s3,
+    datasource.options.gcs,
+  ].filter(Boolean).length;
+  if (ingestionConfigCount > 1) {
+    throw new Error("Datasource can only define one ingestion option: `kafka`, `s3`, or `gcs`.");
   }
 
   // Add description if present
@@ -311,6 +335,13 @@ export function generateDatasource(
   // Add engine configuration
   parts.push(generateEngineConfig(datasource.options.engine));
 
+  // Add indexes if present
+  const indexes = generateIndexes(datasource.options.indexes);
+  if (indexes) {
+    parts.push("");
+    parts.push(indexes);
+  }
+
   // Add Kafka configuration if present
   if (datasource.options.kafka) {
     parts.push("");
@@ -320,7 +351,13 @@ export function generateDatasource(
   // Add S3 configuration if present
   if (datasource.options.s3) {
     parts.push("");
-    parts.push(generateS3Config(datasource.options.s3));
+    parts.push(generateImportConfig(datasource.options.s3));
+  }
+
+  // Add GCS configuration if present
+  if (datasource.options.gcs) {
+    parts.push("");
+    parts.push(generateImportConfig(datasource.options.gcs));
   }
 
   // Add forward query if present

package/src/generator/pipe.test.ts

@@ -164,6 +164,27 @@ describe('Pipe Generator', () => {
       const result = generatePipe(pipe);
       expect(result.content).toContain('    %\n');
     });
+
+    it('injects param defaults into placeholders when SQL omits them', () => {
+      const pipe = definePipe('defaults_pipe', {
+        params: {
+          start_date: p.date().optional('2025-03-01'),
+          page: p.int32().optional(0),
+        },
+        nodes: [
+          node({
+            name: 'endpoint',
+            sql: 'SELECT * FROM events WHERE d >= {{Date(start_date)}} LIMIT 10 OFFSET {{Int32(page)}}',
+          }),
+        ],
+        output: simpleOutput,
+        endpoint: true,
+      });
+
+      const result = generatePipe(pipe);
+      expect(result.content).toContain("{{ Date(start_date, '2025-03-01') }}");
+      expect(result.content).toContain('{{ Int32(page, 0) }}');
+    });
   });
 
   describe('Multiple nodes', () => {

package/src/generator/pipe.ts

@@ -18,6 +18,8 @@ import {
   getCopyConfig,
   getSinkConfig,
 } from "../schema/pipe.js";
+import type { AnyParamValidator } from "../schema/params.js";
+import { getParamDefault } from "../schema/params.js";
 
 /**
  * Generated pipe content
@@ -36,10 +38,123 @@ function hasDynamicParameters(sql: string): boolean {
   return /\{\{[^}]+\}\}/.test(sql) || /\{%[^%]+%\}/.test(sql);
 }
 
+function splitTopLevelComma(input: string): string[] {
+  const parts: string[] = [];
+  let current = "";
+  let depth = 0;
+  let inSingleQuote = false;
+  let inDoubleQuote = false;
+
+  for (let i = 0; i < input.length; i += 1) {
+    const char = input[i];
+    const prev = i > 0 ? input[i - 1] : "";
+
+    if (char === "'" && !inDoubleQuote && prev !== "\\") {
+      inSingleQuote = !inSingleQuote;
+      current += char;
+      continue;
+    }
+
+    if (char === '"' && !inSingleQuote && prev !== "\\") {
+      inDoubleQuote = !inDoubleQuote;
+      current += char;
+      continue;
+    }
+
+    if (!inSingleQuote && !inDoubleQuote) {
+      if (char === "(") {
+        depth += 1;
+        current += char;
+        continue;
+      }
+      if (char === ")" && depth > 0) {
+        depth -= 1;
+        current += char;
+        continue;
+      }
+      if (char === "," && depth === 0) {
+        parts.push(current.trim());
+        current = "";
+        continue;
+      }
+    }
+
+    current += char;
+  }
+
+  if (current.trim()) {
+    parts.push(current.trim());
+  }
+
+  return parts;
+}
+
+function toTemplateDefaultLiteral(value: string | number | boolean): string {
+  if (typeof value === "string") {
+    return `'${value.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+  }
+  return String(value);
+}
+
+function applyParamDefaultsToSql(
+  sql: string,
+  params?: Record<string, AnyParamValidator>
+): string {
+  if (!params) {
+    return sql;
+  }
+
+  const defaults = new Map<string, string>();
+  for (const [name, validator] of Object.entries(params)) {
+    const defaultValue = getParamDefault(validator);
+    if (defaultValue !== undefined) {
+      defaults.set(name, toTemplateDefaultLiteral(defaultValue as string | number | boolean));
+    }
+  }
+
+  if (defaults.size === 0) {
+    return sql;
+  }
+
+  const placeholderRegex = /\{\{\s*([^{}]+?)\s*\}\}/g;
+  return sql.replace(placeholderRegex, (fullMatch, rawExpression) => {
+    const expression = String(rawExpression);
+    const rewritten = expression.replace(
+      /([a-zA-Z_][a-zA-Z0-9_]*)\s*\(([^()]*)\)/g,
+      (call, _functionName, rawArgs) => {
+        const args = splitTopLevelComma(String(rawArgs));
+        if (args.length !== 1) {
+          return call;
+        }
+
+        const paramName = args[0]?.trim() ?? "";
+        if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(paramName)) {
+          return call;
+        }
+
+        const defaultLiteral = defaults.get(paramName);
+        if (!defaultLiteral) {
+          return call;
+        }
+
+        return call.replace(/\)\s*$/, `, ${defaultLiteral})`);
+      }
+    );
+
+    if (rewritten === expression) {
+      return fullMatch;
+    }
+    return `{{ ${rewritten.trim()} }}`;
+  });
+}
+
 /**
  * Generate a NODE section for the pipe
  */
-function generateNode(node: NodeDefinition): string {
+function generateNode(
+  node: NodeDefinition,
+  params?: Record<string, AnyParamValidator>
+): string {
   const parts: string[] = [];
 
   parts.push(`NODE ${node._name}`);
@@ -57,7 +172,8 @@ function generateNode(node: NodeDefinition): string {
     parts.push(`    %`);
   }
 
-  const sqlLines = node.sql.trim().split("\n");
+  const sqlWithDefaults = applyParamDefaultsToSql(node.sql, params);
+  const sqlLines = sqlWithDefaults.trim().split("\n");
   sqlLines.forEach((line) => {
     parts.push(`    ${line}`);
   });
@@ -225,7 +341,7 @@ export function generatePipe(pipe: PipeDefinition): GeneratedPipe {
 
   // Add all nodes
   pipe.options.nodes.forEach((node, index) => {
-    parts.push(generateNode(node));
+    parts.push(generateNode(node, pipe.options.params as Record<string, AnyParamValidator> | undefined));
     // Add empty line between nodes
     if (index < pipe.options.nodes.length - 1) {
       parts.push("");

package/src/index.ts

@@ -113,6 +113,8 @@ export type {
   ExtractSchema,
   KafkaConfig,
   S3Config,
+  GCSConfig,
+  DatasourceIndex,
 } from "./schema/datasource.js";
 
 // ============ Connection ============
@@ -120,9 +122,11 @@ export {
   defineKafkaConnection,
   createKafkaConnection,
   defineS3Connection,
+  defineGCSConnection,
   isConnectionDefinition,
   isKafkaConnectionDefinition,
   isS3ConnectionDefinition,
+  isGCSConnectionDefinition,
   getConnectionType,
 } from "./schema/connection.js";
 export type {
@@ -133,6 +137,8 @@ export type {
   KafkaSaslMechanism,
   S3ConnectionDefinition,
   S3ConnectionOptions,
+  GCSConnectionDefinition,
+  GCSConnectionOptions,
 } from "./schema/connection.js";
 
 // ============ Token ============

package/src/migrate/emit-ts.ts

@@ -4,6 +4,7 @@ import { parseLiteralFromDatafile, toTsLiteral } from "./parser-utils.js";
 import type {
   DatasourceModel,
   DatasourceEngineModel,
+  GCSConnectionModel,
   KafkaConnectionModel,
   ParsedResource,
   PipeModel,
@@ -59,11 +60,13 @@ function hasSecretTemplate(resources: ParsedResource[]): boolean {
         if (resource.secret) values.push(resource.secret);
         if (resource.sslCaPem) values.push(resource.sslCaPem);
         if (resource.schemaRegistryUrl) values.push(resource.schemaRegistryUrl);
-      } else {
+      } else if (resource.connectionType === "s3") {
         values.push(resource.region);
         if (resource.arn) values.push(resource.arn);
         if (resource.accessKey) values.push(resource.accessKey);
         if (resource.secret) values.push(resource.secret);
+      } else {
+        values.push(resource.serviceAccountCredentialsJson);
       }
       continue;
     }
@@ -80,6 +83,11 @@ function hasSecretTemplate(resources: ParsedResource[]): boolean {
         if (resource.s3.schedule) values.push(resource.s3.schedule);
         if (resource.s3.fromTimestamp) values.push(resource.s3.fromTimestamp);
       }
+      if (resource.gcs) {
+        values.push(resource.gcs.bucketUri);
+        if (resource.gcs.schedule) values.push(resource.gcs.schedule);
+        if (resource.gcs.fromTimestamp) values.push(resource.gcs.fromTimestamp);
+      }
       continue;
     }
   }
@@ -125,6 +133,8 @@ function strictParamBaseValidator(type: string): string {
   const map: Record<string, string> = {
     String: "p.string()",
     UUID: "p.uuid()",
+    Int: "p.int32()",
+    Integer: "p.int32()",
     Int8: "p.int8()",
     Int16: "p.int16()",
     Int32: "p.int32()",
@@ -141,6 +151,8 @@ function strictParamBaseValidator(type: string): string {
     DateTime: "p.dateTime()",
     DateTime64: "p.dateTime64()",
     Array: "p.array(p.string())",
+    column: "p.column()",
+    JSON: "p.json()",
   };
   const validator = map[type];
   if (!validator) {
@@ -305,6 +317,15 @@ function emitDatasource(ds: DatasourceModel): string {
   if (ds.engine) {
     lines.push(`  engine: ${emitEngineOptions(ds.engine)},`);
   }
+  if (ds.indexes.length > 0) {
+    lines.push("  indexes: [");
+    for (const index of ds.indexes) {
+      lines.push(
+        `    { name: ${escapeString(index.name)}, expr: ${escapeString(index.expr)}, type: ${escapeString(index.type)}, granularity: ${index.granularity} },`
+      );
+    }
+    lines.push("  ],");
+  }
 
   if (ds.kafka) {
     const connectionVar = toCamelCase(ds.kafka.connectionName);
@@ -337,6 +358,20 @@ function emitDatasource(ds: DatasourceModel): string {
     lines.push("  },");
   }
 
+  if (ds.gcs) {
+    const connectionVar = toCamelCase(ds.gcs.connectionName);
+    lines.push("  gcs: {");
+    lines.push(`    connection: ${connectionVar},`);
+    lines.push(`    bucketUri: ${emitStringOrSecret(ds.gcs.bucketUri)},`);
+    if (ds.gcs.schedule) {
+      lines.push(`    schedule: ${emitStringOrSecret(ds.gcs.schedule)},`);
+    }
+    if (ds.gcs.fromTimestamp) {
+      lines.push(`    fromTimestamp: ${emitStringOrSecret(ds.gcs.fromTimestamp)},`);
+    }
+    lines.push("  },");
+  }
+
   if (ds.forwardQuery) {
     lines.push("  forwardQuery: `");
     lines.push(ds.forwardQuery.replace(/`/g, "\\`").replace(/\${/g, "\\${"));
@@ -364,7 +399,9 @@ function emitDatasource(ds: DatasourceModel): string {
   return lines.join("\n");
 }
 
-function emitConnection(connection: KafkaConnectionModel | S3ConnectionModel): string {
+function emitConnection(
+  connection: KafkaConnectionModel | S3ConnectionModel | GCSConnectionModel
+): string {
   const variableName = toCamelCase(connection.name);
   const lines: string[] = [];
 
@@ -396,19 +433,31 @@ function emitConnection(connection: KafkaConnectionModel | S3ConnectionModel): s
     return lines.join("\n");
   }
 
+  if (connection.connectionType === "s3") {
+    lines.push(
+      `export const ${variableName} = defineS3Connection(${escapeString(connection.name)}, {`
+    );
+    lines.push(`  region: ${emitStringOrSecret(connection.region)},`);
+    if (connection.arn) {
+      lines.push(`  arn: ${emitStringOrSecret(connection.arn)},`);
+    }
+    if (connection.accessKey) {
+      lines.push(`  accessKey: ${emitStringOrSecret(connection.accessKey)},`);
+    }
+    if (connection.secret) {
+      lines.push(`  secret: ${emitStringOrSecret(connection.secret)},`);
+    }
+    lines.push("});");
+    lines.push("");
+    return lines.join("\n");
+  }
+
   lines.push(
-    `export const ${variableName} = defineS3Connection(${escapeString(connection.name)}, {`
+    `export const ${variableName} = defineGCSConnection(${escapeString(connection.name)}, {`
+  );
+  lines.push(
+    `  serviceAccountCredentialsJson: ${emitStringOrSecret(connection.serviceAccountCredentialsJson)},`
   );
-  lines.push(`  region: ${emitStringOrSecret(connection.region)},`);
-  if (connection.arn) {
-    lines.push(`  arn: ${emitStringOrSecret(connection.arn)},`);
-  }
-  if (connection.accessKey) {
-    lines.push(`  accessKey: ${emitStringOrSecret(connection.accessKey)},`);
-  }
-  if (connection.secret) {
-    lines.push(`  secret: ${emitStringOrSecret(connection.secret)},`);
-  }
   lines.push("});");
   lines.push("");
   return lines.join("\n");
@@ -542,7 +591,7 @@ function emitPipe(pipe: PipeModel): string {
 
 export function emitMigrationFileContent(resources: ParsedResource[]): string {
   const connections = resources.filter(
-    (resource): resource is KafkaConnectionModel | S3ConnectionModel =>
+    (resource): resource is KafkaConnectionModel | S3ConnectionModel | GCSConnectionModel =>
       resource.kind === "connection"
   );
   const datasources = resources.filter(
@@ -569,6 +618,9 @@ export function emitMigrationFileContent(resources: ParsedResource[]): string {
   if (connections.some((connection) => connection.connectionType === "s3")) {
     imports.add("defineS3Connection");
   }
+  if (connections.some((connection) => connection.connectionType === "gcs")) {
+    imports.add("defineGCSConnection");
+  }
   if (needsParams) {
     imports.add("p");
   }
@@ -585,6 +637,7 @@ export function emitMigrationFileContent(resources: ParsedResource[]): string {
   const orderedImports = [
     "defineKafkaConnection",
     "defineS3Connection",
+    "defineGCSConnection",
     "defineDatasource",
     "definePipe",
     "defineMaterializedView",