@squadbase/connectors 0.1.1 → 0.1.2-dev.1

package/dist/sdk.d.ts

@@ -34,7 +34,7 @@ interface KintoneConnectorSdk {
  * @param params - Resolved parameter values keyed by parameter slug
  *                 ("base-url", "username", "password")
  */
-declare function createClient$5(params: Record<string, string>): KintoneConnectorSdk;
+declare function createClient$8(params: Record<string, string>): KintoneConnectorSdk;
 
 interface OpenAIConnectorSdk {
     apiKey: string;
@@ -44,7 +44,7 @@ interface OpenAIConnectorSdk {
  *
  * @param params - Resolved parameter values keyed by parameter slug ("api-key")
  */
-declare function createClient$4(params: Record<string, string>): OpenAIConnectorSdk;
+declare function createClient$7(params: Record<string, string>): OpenAIConnectorSdk;
 
 /** Shape returned by the Airtable API for a single record. */
 interface AirtableRecord {
@@ -131,7 +131,44 @@ interface AirtableConnectorSdk {
  * @param params - Resolved parameter values keyed by parameter slug
  *                 ("base-id", "api-key")
  */
-declare function createClient$3(params: Record<string, string>): AirtableConnectorSdk;
+declare function createClient$6(params: Record<string, string>): AirtableConnectorSdk;
+
+interface GoogleAdsRow {
+    [key: string]: unknown;
+}
+interface GoogleAdsConnectorSdk {
+    /**
+     * Send an authenticated request to the Google Ads API v18.
+     *
+     * The placeholder `{customerId}` in the path is auto-replaced with the configured customer ID.
+     *
+     * @param path - API path (e.g., "customers/{customerId}/googleAds:searchStream")
+     * @param init - Standard RequestInit (same as fetch)
+     * @returns Standard Response (same as fetch)
+     */
+    request(path: string, init?: RequestInit): Promise<Response>;
+    /**
+     * Execute a GAQL (Google Ads Query Language) query using searchStream.
+     *
+     * @param query - GAQL query string
+     * @param customerId - Override the default customer ID
+     * @returns Array of result rows
+     *
+     * @see https://developers.google.com/google-ads/api/docs/query/overview
+     */
+    search(query: string, customerId?: string): Promise<GoogleAdsRow[]>;
+    /**
+     * List accessible customer accounts.
+     */
+    listAccessibleCustomers(): Promise<string[]>;
+}
+/**
+ * Create a Google Ads client from resolved connection parameters.
+ *
+ * @param params - Resolved parameter values keyed by parameter slug
+ * @param fetchFn - Optional fetch function (for OAuth proxy injection)
+ */
+declare function createClient$5(params: Record<string, string>, fetchFn?: typeof fetch): GoogleAdsConnectorSdk;
 
 interface GoogleAnalyticsConnectorSdk {
     /**
@@ -237,7 +274,181 @@ interface GoogleAnalyticsConnectorSdk {
  * @param params - Resolved parameter values keyed by parameter slug
  *                 ("service-account-key-json-base64", "property-id")
  */
-declare function createClient$2(params: Record<string, string>): GoogleAnalyticsConnectorSdk;
+declare function createClient$4(params: Record<string, string>): GoogleAnalyticsConnectorSdk;
+
+interface GoogleAnalyticsOauthConnectorSdk {
+    /**
+     * Send an authenticated request to the Google Analytics Data API v1beta.
+     *
+     * Occurrences of `{propertyId}` in the path are auto-replaced with the configured property ID.
+     *
+     * @param path - API path (e.g., "properties/{propertyId}:runReport")
+     * @param init - Standard RequestInit (same as fetch)
+     * @returns Standard Response (same as fetch)
+     */
+    request(path: string, init?: RequestInit): Promise<Response>;
+    /**
+     * Run a GA4 report.
+     *
+     * @see https://developers.google.com/analytics/devguides/reporting/data/v1/rest/v1beta/properties/runReport
+     */
+    runReport(request: {
+        dateRanges: {
+            startDate: string;
+            endDate: string;
+        }[];
+        dimensions?: {
+            name: string;
+        }[];
+        metrics: {
+            name: string;
+        }[];
+        limit?: number;
+        offset?: number;
+        dimensionFilter?: Record<string, unknown>;
+        metricFilter?: Record<string, unknown>;
+        orderBys?: Record<string, unknown>[];
+    }): Promise<{
+        rows: {
+            dimensionValues: {
+                value: string;
+            }[];
+            metricValues: {
+                value: string;
+            }[];
+        }[];
+        rowCount: number;
+    }>;
+    /**
+     * Get available dimensions and metrics for a property.
+     *
+     * @see https://developers.google.com/analytics/devguides/reporting/data/v1/rest/v1beta/properties/getMetadata
+     */
+    getMetadata(): Promise<{
+        name: string;
+        dimensions: {
+            apiName: string;
+            uiName: string;
+            description: string;
+            [key: string]: unknown;
+        }[];
+        metrics: {
+            apiName: string;
+            uiName: string;
+            description: string;
+            type: string;
+            [key: string]: unknown;
+        }[];
+    }>;
+    /**
+     * Run a realtime report.
+     *
+     * @see https://developers.google.com/analytics/devguides/reporting/data/v1/rest/v1beta/properties/runRealtimeReport
+     */
+    runRealtimeReport(request: {
+        dimensions?: {
+            name: string;
+        }[];
+        metrics: {
+            name: string;
+        }[];
+        limit?: number;
+        dimensionFilter?: Record<string, unknown>;
+        metricFilter?: Record<string, unknown>;
+        minuteRanges?: {
+            startMinutesAgo?: number;
+            endMinutesAgo?: number;
+            name?: string;
+        }[];
+    }): Promise<{
+        rows: {
+            dimensionValues: {
+                value: string;
+            }[];
+            metricValues: {
+                value: string;
+            }[];
+        }[];
+        rowCount: number;
+    }>;
+}
+/**
+ * Create a Google Analytics client from resolved connection parameters.
+ *
+ * @param params - Resolved parameter values keyed by parameter slug
+ * @param fetchFn - Optional fetch function (for OAuth proxy injection)
+ */
+declare function createClient$3(params: Record<string, string>, fetchFn?: typeof fetch): GoogleAnalyticsOauthConnectorSdk;
+
+interface SpreadsheetProperties {
+    title: string;
+    locale?: string;
+    timeZone?: string;
+}
+interface SheetProperties {
+    sheetId: number;
+    title: string;
+    index: number;
+    sheetType?: string;
+    gridProperties?: {
+        rowCount: number;
+        columnCount: number;
+    };
+}
+interface SpreadsheetMetadata {
+    spreadsheetId: string;
+    properties: SpreadsheetProperties;
+    sheets: {
+        properties: SheetProperties;
+    }[];
+}
+interface ValueRange {
+    range: string;
+    majorDimension: string;
+    values: unknown[][];
+}
+interface BatchValueRange {
+    spreadsheetId: string;
+    valueRanges: ValueRange[];
+}
+interface GoogleSheetsConnectorSdk {
+    /**
+     * Send an authenticated request to the Google Sheets API v4.
+     *
+     * The placeholder `{spreadsheetId}` in the path is automatically replaced
+     * with the configured default Spreadsheet ID.
+     *
+     * @param path - API path (e.g., "/{spreadsheetId}/values/Sheet1!A1:D10")
+     * @param init - Standard RequestInit (same as fetch)
+     * @returns Standard Response (same as fetch)
+     */
+    request(path: string, init?: RequestInit): Promise<Response>;
+    /**
+     * Get spreadsheet metadata including sheet names and properties.
+     */
+    getSpreadsheet(spreadsheetId?: string): Promise<SpreadsheetMetadata>;
+    /**
+     * Get cell values for a given range (A1 notation).
+     *
+     * @param range - A1 notation range (e.g., "Sheet1!A1:D10")
+     * @param spreadsheetId - Override the default spreadsheet ID
+     */
+    getValues(range: string, spreadsheetId?: string): Promise<ValueRange>;
+    /**
+     * Get cell values for multiple ranges in one request.
+     *
+     * @param ranges - Array of A1 notation ranges
+     * @param spreadsheetId - Override the default spreadsheet ID
+     */
+    batchGetValues(ranges: string[], spreadsheetId?: string): Promise<BatchValueRange>;
+}
+/**
+ * Create a Google Sheets client from resolved connection parameters.
+ *
+ * @param params - Resolved parameter values keyed by parameter slug
+ * @param fetchFn - Optional fetch function (for OAuth proxy injection)
+ */
+declare function createClient$2(params: Record<string, string>, fetchFn?: typeof fetch): GoogleSheetsConnectorSdk;
 
 interface WixStoreConnectorSdk {
     /**
@@ -386,4 +597,4 @@ interface DbtConnectorSdk {
  */
 declare function createClient(params: Record<string, string>): DbtConnectorSdk;
 
-export { type AirtableConnectorSdk, type DbtConnectorSdk, type GoogleAnalyticsConnectorSdk, type KintoneConnectorSdk, type OpenAIConnectorSdk, type WixStoreConnectorSdk, createClient$3 as airtable, createClient as dbt, createClient$2 as googleAnalytics, createClient$5 as kintone, createClient$4 as openai, createClient$1 as wixStore };
+export { type AirtableConnectorSdk, type DbtConnectorSdk, type GoogleAdsConnectorSdk, type GoogleAnalyticsConnectorSdk, type GoogleAnalyticsOauthConnectorSdk, type GoogleSheetsConnectorSdk, type KintoneConnectorSdk, type OpenAIConnectorSdk, type WixStoreConnectorSdk, createClient$6 as airtable, createClient as dbt, createClient$5 as googleAds, createClient$4 as googleAnalytics, createClient$3 as googleAnalyticsOauth, createClient$2 as googleSheets, createClient$8 as kintone, createClient$7 as openai, createClient$1 as wixStore };

package/dist/sdk.js

@@ -4,19 +4,22 @@ import {
   parameters3,
   parameters4,
   parameters5,
-  parameters6
-} from "./chunk-4K4NERCT.js";
+  parameters6,
+  parameters7,
+  parameters8,
+  parameters9
+} from "./chunk-LB7J6VXK.js";
 
 // src/connectors/kintone/sdk/index.ts
 function createClient(params) {
-  const baseUrl = params[parameters3.baseUrl.slug];
-  const username = params[parameters3.username.slug];
-  const password = params[parameters3.password.slug];
+  const baseUrl = params[parameters6.baseUrl.slug];
+  const username = params[parameters6.username.slug];
+  const password = params[parameters6.password.slug];
   if (!baseUrl || !username || !password) {
     const required = [
-      parameters3.baseUrl.slug,
-      parameters3.username.slug,
-      parameters3.password.slug
+      parameters6.baseUrl.slug,
+      parameters6.username.slug,
+      parameters6.password.slug
     ];
     const missing = required.filter((s) => !params[s]);
     throw new Error(
@@ -78,10 +81,10 @@ function createClient(params) {
 
 // src/connectors/openai/sdk/index.ts
 function createClient2(params) {
-  const apiKey = params[parameters6.apiKey.slug];
+  const apiKey = params[parameters9.apiKey.slug];
   if (!apiKey) {
     throw new Error(
-      `openai: missing required parameter: ${parameters6.apiKey.slug}`
+      `openai: missing required parameter: ${parameters9.apiKey.slug}`
     );
   }
   return { apiKey };
@@ -220,10 +223,84 @@ function createClient3(params) {
   };
 }
 
+// src/connectors/google-ads-oauth/sdk/index.ts
+var BASE_URL2 = "https://googleads.googleapis.com/v18/";
+function createClient4(params, fetchFn = fetch) {
+  const rawCustomerId = params[parameters2.customerId.slug];
+  const defaultCustomerId = rawCustomerId?.replace(/-/g, "") ?? "";
+  const developerToken = params[parameters2.developerToken.slug];
+  if (!developerToken) {
+    throw new Error(
+      `google-ads: missing required parameter: ${parameters2.developerToken.slug}`
+    );
+  }
+  function resolveCustomerId(override) {
+    const id = override?.replace(/-/g, "") ?? defaultCustomerId;
+    if (!id) {
+      throw new Error(
+        "google-ads: customerId is required. Either configure a default or pass it explicitly."
+      );
+    }
+    return id;
+  }
+  function request(path, init) {
+    const resolvedPath = defaultCustomerId ? path.replace(/\{customerId\}/g, defaultCustomerId) : path;
+    const url = `${BASE_URL2}${resolvedPath}`;
+    const headers = new Headers(init?.headers);
+    headers.set("developer-token", developerToken);
+    if (defaultCustomerId) {
+      headers.set("login-customer-id", defaultCustomerId);
+    }
+    return fetchFn(url, { ...init, headers });
+  }
+  async function search(query, customerId) {
+    const cid = resolveCustomerId(customerId);
+    const url = `${BASE_URL2}customers/${cid}/googleAds:searchStream`;
+    const headers = new Headers();
+    headers.set("Content-Type", "application/json");
+    headers.set("developer-token", developerToken);
+    headers.set("login-customer-id", cid);
+    const response = await fetchFn(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ query })
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(
+        `google-ads: search failed (${response.status}): ${body}`
+      );
+    }
+    const data = await response.json();
+    return data.flatMap((chunk) => chunk.results ?? []);
+  }
+  async function listAccessibleCustomers() {
+    const url = `${BASE_URL2}customers:listAccessibleCustomers`;
+    const headers = new Headers();
+    headers.set("developer-token", developerToken);
+    const response = await fetchFn(url, { method: "GET", headers });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(
+        `google-ads: listAccessibleCustomers failed (${response.status}): ${body}`
+      );
+    }
+    const data = await response.json();
+    return (data.resourceNames ?? []).map(
+      (rn) => rn.replace(/^customers\//, "")
+    );
+  }
+  return {
+    request,
+    search,
+    listAccessibleCustomers
+  };
+}
+
 // src/connectors/google-analytics/sdk/index.ts
 import * as crypto from "crypto";
 var TOKEN_URL = "https://oauth2.googleapis.com/token";
-var BASE_URL2 = "https://analyticsdata.googleapis.com/v1beta/";
+var BASE_URL3 = "https://analyticsdata.googleapis.com/v1beta/";
 var SCOPE = "https://www.googleapis.com/auth/analytics.readonly";
 function base64url(input) {
   const buf = typeof input === "string" ? Buffer.from(input) : input;
@@ -247,13 +324,13 @@ function buildJwt(clientEmail, privateKey, nowSec) {
   const signature = base64url(sign.sign(privateKey));
   return `${signingInput}.${signature}`;
 }
-function createClient4(params) {
-  const serviceAccountKeyJsonBase64 = params[parameters2.serviceAccountKeyJsonBase64.slug];
-  const propertyId = params[parameters2.propertyId.slug];
+function createClient5(params) {
+  const serviceAccountKeyJsonBase64 = params[parameters3.serviceAccountKeyJsonBase64.slug];
+  const propertyId = params[parameters3.propertyId.slug];
   if (!serviceAccountKeyJsonBase64 || !propertyId) {
     const required = [
-      parameters2.serviceAccountKeyJsonBase64.slug,
-      parameters2.propertyId.slug
+      parameters3.serviceAccountKeyJsonBase64.slug,
+      parameters3.propertyId.slug
     ];
     const missing = required.filter((s) => !params[s]);
     throw new Error(
@@ -312,7 +389,7 @@ function createClient4(params) {
     async request(path, init) {
       const accessToken = await getAccessToken();
       const resolvedPath = path.replace(/\{propertyId\}/g, propertyId);
-      const url = `${BASE_URL2.replace(/\/+$/, "")}/${resolvedPath.replace(/^\/+/, "")}`;
+      const url = `${BASE_URL3.replace(/\/+$/, "")}/${resolvedPath.replace(/^\/+/, "")}`;
       const headers = new Headers(init?.headers);
       headers.set("Authorization", `Bearer ${accessToken}`);
       return fetch(url, { ...init, headers });
@@ -375,16 +452,162 @@ function createClient4(params) {
   };
 }
 
+// src/connectors/google-analytics-oauth/sdk/index.ts
+var BASE_URL4 = "https://analyticsdata.googleapis.com/v1beta/";
+function createClient6(params, fetchFn = fetch) {
+  const propertyId = params[parameters4.propertyId.slug];
+  function resolvePropertyId() {
+    if (!propertyId) {
+      throw new Error(
+        "google-analytics-oauth: propertyId is required. Configure it via connection parameters."
+      );
+    }
+    return propertyId;
+  }
+  return {
+    async request(path, init) {
+      const pid = propertyId;
+      const resolvedPath = pid ? path.replace(/\{propertyId\}/g, pid) : path;
+      const url = `${BASE_URL4.replace(/\/+$/, "")}/${resolvedPath.replace(/^\/+/, "")}`;
+      return fetchFn(url, init);
+    },
+    async runReport(request) {
+      const pid = resolvePropertyId();
+      const response = await this.request(
+        `properties/${pid}:runReport`,
+        {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(request)
+        }
+      );
+      if (!response.ok) {
+        const text = await response.text();
+        throw new Error(
+          `google-analytics-oauth: runReport failed (${response.status}): ${text}`
+        );
+      }
+      const data = await response.json();
+      return {
+        rows: data.rows ?? [],
+        rowCount: data.rowCount ?? 0
+      };
+    },
+    async getMetadata() {
+      const pid = resolvePropertyId();
+      const response = await this.request(
+        `properties/${pid}/metadata`,
+        { method: "GET" }
+      );
+      if (!response.ok) {
+        const text = await response.text();
+        throw new Error(
+          `google-analytics-oauth: getMetadata failed (${response.status}): ${text}`
+        );
+      }
+      return await response.json();
+    },
+    async runRealtimeReport(request) {
+      const pid = resolvePropertyId();
+      const response = await this.request(
+        `properties/${pid}:runRealtimeReport`,
+        {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(request)
+        }
+      );
+      if (!response.ok) {
+        const text = await response.text();
+        throw new Error(
+          `google-analytics-oauth: runRealtimeReport failed (${response.status}): ${text}`
+        );
+      }
+      const data = await response.json();
+      return {
+        rows: data.rows ?? [],
+        rowCount: data.rowCount ?? 0
+      };
+    }
+  };
+}
+
+// src/connectors/google-sheets-oauth/sdk/index.ts
+var BASE_URL5 = "https://sheets.googleapis.com/v4/spreadsheets";
+function createClient7(params, fetchFn = fetch) {
+  const defaultSpreadsheetId = params[parameters5.spreadsheetId.slug];
+  function resolveSpreadsheetId(override) {
+    const id = override ?? defaultSpreadsheetId;
+    if (!id) {
+      throw new Error(
+        "google-sheets: spreadsheetId is required. Either configure a default or pass it explicitly."
+      );
+    }
+    return id;
+  }
+  function request(path, init) {
+    const resolvedPath = defaultSpreadsheetId ? path.replace(/\{spreadsheetId\}/g, defaultSpreadsheetId) : path;
+    const url = `${BASE_URL5}${resolvedPath.startsWith("/") ? "" : "/"}${resolvedPath}`;
+    return fetchFn(url, init);
+  }
+  async function getSpreadsheet(spreadsheetId) {
+    const id = resolveSpreadsheetId(spreadsheetId);
+    const url = `${BASE_URL5}/${id}?fields=spreadsheetId,properties,sheets.properties`;
+    const response = await fetchFn(url);
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(
+        `google-sheets: getSpreadsheet failed (${response.status}): ${body}`
+      );
+    }
+    return await response.json();
+  }
+  async function getValues(range, spreadsheetId) {
+    const id = resolveSpreadsheetId(spreadsheetId);
+    const url = `${BASE_URL5}/${id}/values/${encodeURIComponent(range)}`;
+    const response = await fetchFn(url);
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(
+        `google-sheets: getValues failed (${response.status}): ${body}`
+      );
+    }
+    return await response.json();
+  }
+  async function batchGetValues(ranges, spreadsheetId) {
+    const id = resolveSpreadsheetId(spreadsheetId);
+    const searchParams = new URLSearchParams();
+    for (const range of ranges) {
+      searchParams.append("ranges", range);
+    }
+    const url = `${BASE_URL5}/${id}/values:batchGet?${searchParams.toString()}`;
+    const response = await fetchFn(url);
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(
+        `google-sheets: batchGetValues failed (${response.status}): ${body}`
+      );
+    }
+    return await response.json();
+  }
+  return {
+    request,
+    getSpreadsheet,
+    getValues,
+    batchGetValues
+  };
+}
+
 // src/connectors/wix-store/sdk/index.ts
-function createClient5(params) {
-  const accountId = params[parameters4.accountId.slug];
-  const siteId = params[parameters4.siteId.slug];
-  const apiKey = params[parameters4.apiKey.slug];
+function createClient8(params) {
+  const accountId = params[parameters7.accountId.slug];
+  const siteId = params[parameters7.siteId.slug];
+  const apiKey = params[parameters7.apiKey.slug];
   if (!accountId || !siteId || !apiKey) {
     const required = [
-      parameters4.accountId.slug,
-      parameters4.siteId.slug,
-      parameters4.apiKey.slug
+      parameters7.accountId.slug,
+      parameters7.siteId.slug,
+      parameters7.apiKey.slug
     ];
     const missing = required.filter((s) => !params[s]);
     throw new Error(
@@ -502,15 +725,15 @@ function createClient5(params) {
 }
 
 // src/connectors/dbt/sdk/index.ts
-function createClient6(params) {
-  const host = params[parameters5.host.slug];
-  const prodEnvId = params[parameters5.prodEnvId.slug];
-  const token = params[parameters5.token.slug];
+function createClient9(params) {
+  const host = params[parameters8.host.slug];
+  const prodEnvId = params[parameters8.prodEnvId.slug];
+  const token = params[parameters8.token.slug];
   if (!host || !prodEnvId || !token) {
     const required = [
-      parameters5.host.slug,
-      parameters5.prodEnvId.slug,
-      parameters5.token.slug
+      parameters8.host.slug,
+      parameters8.prodEnvId.slug,
+      parameters8.token.slug
     ];
     const missing = required.filter((s) => !params[s]);
     throw new Error(
@@ -737,9 +960,12 @@ function createClient6(params) {
 }
 export {
   createClient3 as airtable,
-  createClient6 as dbt,
-  createClient4 as googleAnalytics,
+  createClient9 as dbt,
+  createClient4 as googleAds,
+  createClient5 as googleAnalytics,
+  createClient6 as googleAnalyticsOauth,
+  createClient7 as googleSheets,
   createClient as kintone,
   createClient2 as openai,
-  createClient5 as wixStore
+  createClient8 as wixStore
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@squadbase/connectors",
-  "version": "0.1.1",
+  "version": "0.1.2-dev.1",
   "description": "Squadbase Connectors",
   "type": "module",
   "main": "dist/index.js",