@squadbase/connectors 0.0.12 → 0.0.14

package/dist/sdk.js

@@ -1,18 +1,22 @@
 import {
   parameters,
-  parameters2
-} from "./chunk-E5AVUXWJ.js";
+  parameters2,
+  parameters3,
+  parameters4,
+  parameters5,
+  parameters6
+} from "./chunk-4K4NERCT.js";
 
 // src/connectors/kintone/sdk/index.ts
 function createClient(params) {
-  const baseUrl = params[parameters.baseUrl.slug];
-  const username = params[parameters.username.slug];
-  const password = params[parameters.password.slug];
+  const baseUrl = params[parameters3.baseUrl.slug];
+  const username = params[parameters3.username.slug];
+  const password = params[parameters3.password.slug];
   if (!baseUrl || !username || !password) {
     const required = [
-      parameters.baseUrl.slug,
-      parameters.username.slug,
-      parameters.password.slug
+      parameters3.baseUrl.slug,
+      parameters3.username.slug,
+      parameters3.password.slug
     ];
     const missing = required.filter((s) => !params[s]);
     throw new Error(
@@ -74,15 +78,668 @@ function createClient(params) {
 
 // src/connectors/openai/sdk/index.ts
 function createClient2(params) {
-  const apiKey = params[parameters2.apiKey.slug];
+  const apiKey = params[parameters6.apiKey.slug];
   if (!apiKey) {
     throw new Error(
-      `openai: missing required parameter: ${parameters2.apiKey.slug}`
+      `openai: missing required parameter: ${parameters6.apiKey.slug}`
     );
   }
   return { apiKey };
 }
+
+// src/connectors/airtable/sdk/index.ts
+var BASE_URL = "https://api.airtable.com/v0";
+function createClient3(params) {
+  const baseId = params[parameters.baseId.slug];
+  const apiKey = params[parameters.apiKey.slug];
+  if (!baseId || !apiKey) {
+    const required = [parameters.baseId.slug, parameters.apiKey.slug];
+    const missing = required.filter((s) => !params[s]);
+    throw new Error(
+      `airtable: missing required parameters: ${missing.join(", ")}`
+    );
+  }
+  function request(path, init) {
+    const resolvedPath = path.replace(/\{baseId\}/g, baseId);
+    const url = `${BASE_URL}${resolvedPath.startsWith("/") ? "" : "/"}${resolvedPath}`;
+    const headers = new Headers(init?.headers);
+    headers.set("Authorization", `Bearer ${apiKey}`);
+    return fetch(url, { ...init, headers });
+  }
+  async function listRecords(tableIdOrName, options) {
+    const searchParams = new URLSearchParams();
+    if (options?.fields) {
+      for (const field of options.fields) {
+        searchParams.append("fields[]", field);
+      }
+    }
+    if (options?.filterByFormula) {
+      searchParams.set("filterByFormula", options.filterByFormula);
+    }
+    if (options?.maxRecords != null) {
+      searchParams.set("maxRecords", String(options.maxRecords));
+    }
+    if (options?.sort) {
+      for (let i = 0; i < options.sort.length; i++) {
+        searchParams.set(`sort[${i}][field]`, options.sort[i].field);
+        if (options.sort[i].direction) {
+          searchParams.set(
+            `sort[${i}][direction]`,
+            options.sort[i].direction
+          );
+        }
+      }
+    }
+    if (options?.pageSize != null) {
+      searchParams.set("pageSize", String(options.pageSize));
+    }
+    if (options?.view) {
+      searchParams.set("view", options.view);
+    }
+    if (options?.offset) {
+      searchParams.set("offset", options.offset);
+    }
+    const qs = searchParams.toString();
+    const path = `/${baseId}/${encodeURIComponent(tableIdOrName)}${qs ? `?${qs}` : ""}`;
+    const response = await request(path);
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(
+        `airtable: listRecords failed (${response.status}): ${body}`
+      );
+    }
+    return await response.json();
+  }
+  async function getRecord(tableIdOrName, recordId) {
+    const path = `/${baseId}/${encodeURIComponent(tableIdOrName)}/${encodeURIComponent(recordId)}`;
+    const response = await request(path);
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(
+        `airtable: getRecord failed (${response.status}): ${body}`
+      );
+    }
+    return await response.json();
+  }
+  async function createRecords(tableIdOrName, records, options) {
+    const payload = { records };
+    if (options?.typecast != null) {
+      payload.typecast = options.typecast;
+    }
+    const path = `/${baseId}/${encodeURIComponent(tableIdOrName)}`;
+    const response = await request(path, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload)
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(
+        `airtable: createRecords failed (${response.status}): ${body}`
+      );
+    }
+    return await response.json();
+  }
+  async function updateRecords(tableIdOrName, records, options) {
+    const payload = { records };
+    if (options?.typecast != null) {
+      payload.typecast = options.typecast;
+    }
+    const path = `/${baseId}/${encodeURIComponent(tableIdOrName)}`;
+    const response = await request(path, {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload)
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(
+        `airtable: updateRecords failed (${response.status}): ${body}`
+      );
+    }
+    return await response.json();
+  }
+  async function listTables() {
+    const path = `/meta/bases/${baseId}/tables`;
+    const response = await request(path);
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(
+        `airtable: listTables failed (${response.status}): ${body}`
+      );
+    }
+    return await response.json();
+  }
+  return {
+    request,
+    listRecords,
+    getRecord,
+    createRecords,
+    updateRecords,
+    listTables
+  };
+}
+
+// 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 SCOPE = "https://www.googleapis.com/auth/analytics.readonly";
+function base64url(input) {
+  const buf = typeof input === "string" ? Buffer.from(input) : input;
+  return buf.toString("base64url");
+}
+function buildJwt(clientEmail, privateKey, nowSec) {
+  const header = base64url(JSON.stringify({ alg: "RS256", typ: "JWT" }));
+  const payload = base64url(
+    JSON.stringify({
+      iss: clientEmail,
+      scope: SCOPE,
+      aud: TOKEN_URL,
+      iat: nowSec,
+      exp: nowSec + 3600
+    })
+  );
+  const signingInput = `${header}.${payload}`;
+  const sign = crypto.createSign("RSA-SHA256");
+  sign.update(signingInput);
+  sign.end();
+  const signature = base64url(sign.sign(privateKey));
+  return `${signingInput}.${signature}`;
+}
+function createClient4(params) {
+  const serviceAccountKeyJsonBase64 = params[parameters2.serviceAccountKeyJsonBase64.slug];
+  const propertyId = params[parameters2.propertyId.slug];
+  if (!serviceAccountKeyJsonBase64 || !propertyId) {
+    const required = [
+      parameters2.serviceAccountKeyJsonBase64.slug,
+      parameters2.propertyId.slug
+    ];
+    const missing = required.filter((s) => !params[s]);
+    throw new Error(
+      `google-analytics: missing required parameters: ${missing.join(", ")}`
+    );
+  }
+  let serviceAccountKey;
+  try {
+    const decoded = Buffer.from(
+      serviceAccountKeyJsonBase64,
+      "base64"
+    ).toString("utf-8");
+    serviceAccountKey = JSON.parse(decoded);
+  } catch {
+    throw new Error(
+      "google-analytics: failed to decode service account key JSON from base64"
+    );
+  }
+  if (!serviceAccountKey.client_email || !serviceAccountKey.private_key) {
+    throw new Error(
+      "google-analytics: service account key JSON must contain client_email and private_key"
+    );
+  }
+  let cachedToken = null;
+  let tokenExpiresAt = 0;
+  async function getAccessToken() {
+    const nowSec = Math.floor(Date.now() / 1e3);
+    if (cachedToken && nowSec < tokenExpiresAt - 60) {
+      return cachedToken;
+    }
+    const jwt = buildJwt(
+      serviceAccountKey.client_email,
+      serviceAccountKey.private_key,
+      nowSec
+    );
+    const response = await fetch(TOKEN_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: new URLSearchParams({
+        grant_type: "urn:ietf:params:oauth:grant-type:jwt-bearer",
+        assertion: jwt
+      })
+    });
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(
+        `google-analytics: token exchange failed (${response.status}): ${text}`
+      );
+    }
+    const data = await response.json();
+    cachedToken = data.access_token;
+    tokenExpiresAt = nowSec + data.expires_in;
+    return cachedToken;
+  }
+  return {
+    async request(path, init) {
+      const accessToken = await getAccessToken();
+      const resolvedPath = path.replace(/\{propertyId\}/g, propertyId);
+      const url = `${BASE_URL2.replace(/\/+$/, "")}/${resolvedPath.replace(/^\/+/, "")}`;
+      const headers = new Headers(init?.headers);
+      headers.set("Authorization", `Bearer ${accessToken}`);
+      return fetch(url, { ...init, headers });
+    },
+    async runReport(request) {
+      const response = await this.request(
+        `properties/${propertyId}: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: runReport failed (${response.status}): ${text}`
+        );
+      }
+      const data = await response.json();
+      return {
+        rows: data.rows ?? [],
+        rowCount: data.rowCount ?? 0
+      };
+    },
+    async getMetadata() {
+      const response = await this.request(
+        `properties/${propertyId}/metadata`,
+        { method: "GET" }
+      );
+      if (!response.ok) {
+        const text = await response.text();
+        throw new Error(
+          `google-analytics: getMetadata failed (${response.status}): ${text}`
+        );
+      }
+      return await response.json();
+    },
+    async runRealtimeReport(request) {
+      const response = await this.request(
+        `properties/${propertyId}: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: runRealtimeReport failed (${response.status}): ${text}`
+        );
+      }
+      const data = await response.json();
+      return {
+        rows: data.rows ?? [],
+        rowCount: data.rowCount ?? 0
+      };
+    }
+  };
+}
+
+// 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];
+  if (!accountId || !siteId || !apiKey) {
+    const required = [
+      parameters4.accountId.slug,
+      parameters4.siteId.slug,
+      parameters4.apiKey.slug
+    ];
+    const missing = required.filter((s) => !params[s]);
+    throw new Error(
+      `wix-store: missing required parameters: ${missing.join(", ")}`
+    );
+  }
+  const baseUrl = "https://www.wixapis.com";
+  function authHeaders(extra) {
+    const headers = new Headers(extra);
+    headers.set("Authorization", apiKey);
+    headers.set("wix-site-id", siteId);
+    return headers;
+  }
+  async function assertOk(res, label) {
+    if (!res.ok) {
+      const body = await res.text().catch(() => "(unreadable body)");
+      throw new Error(
+        `wix-store ${label}: ${res.status} ${res.statusText} \u2014 ${body}`
+      );
+    }
+  }
+  return {
+    request(path, init) {
+      const url = `${baseUrl}${path}`;
+      const headers = new Headers(init?.headers);
+      headers.set("Authorization", apiKey);
+      headers.set("wix-site-id", siteId);
+      return fetch(url, { ...init, headers });
+    },
+    async queryProducts(options) {
+      const query = {};
+      if (options?.filter) query.filter = options.filter;
+      if (options?.sort) query.sort = options.sort;
+      if (options?.paging) query.paging = options.paging;
+      const res = await fetch(`${baseUrl}/stores/v1/products/query`, {
+        method: "POST",
+        headers: authHeaders({ "Content-Type": "application/json" }),
+        body: JSON.stringify({ query })
+      });
+      await assertOk(res, "queryProducts");
+      const json = await res.json();
+      return {
+        products: json.products ?? [],
+        totalResults: json.totalResults ?? 0
+      };
+    },
+    async getProduct(productId) {
+      const res = await fetch(
+        `${baseUrl}/stores/v1/products/${encodeURIComponent(productId)}`,
+        { method: "GET", headers: authHeaders() }
+      );
+      await assertOk(res, "getProduct");
+      const json = await res.json();
+      return { product: json.product };
+    },
+    async queryOrders(options) {
+      const search = {};
+      if (options?.filter) search.filter = options.filter;
+      if (options?.sort) search.sort = options.sort;
+      if (options?.cursorPaging) search.cursorPaging = options.cursorPaging;
+      const res = await fetch(`${baseUrl}/ecom/v1/orders/search`, {
+        method: "POST",
+        headers: authHeaders({ "Content-Type": "application/json" }),
+        body: JSON.stringify({ search })
+      });
+      await assertOk(res, "queryOrders");
+      const json = await res.json();
+      return {
+        orders: json.orders ?? [],
+        pagingMetadata: json.pagingMetadata
+      };
+    },
+    async getOrder(orderId) {
+      const res = await fetch(
+        `${baseUrl}/ecom/v1/orders/${encodeURIComponent(orderId)}`,
+        { method: "GET", headers: authHeaders() }
+      );
+      await assertOk(res, "getOrder");
+      const json = await res.json();
+      return { order: json.order };
+    },
+    async queryCollections(options) {
+      const query = {};
+      if (options?.filter) query.filter = options.filter;
+      if (options?.sort) query.sort = options.sort;
+      if (options?.paging) query.paging = options.paging;
+      const res = await fetch(`${baseUrl}/stores/v1/collections/query`, {
+        method: "POST",
+        headers: authHeaders({ "Content-Type": "application/json" }),
+        body: JSON.stringify({ query })
+      });
+      await assertOk(res, "queryCollections");
+      const json = await res.json();
+      return {
+        collections: json.collections ?? []
+      };
+    },
+    async queryInventory(options) {
+      const query = {};
+      if (options?.filter) query.filter = options.filter;
+      if (options?.paging) query.paging = options.paging;
+      const res = await fetch(`${baseUrl}/stores/v2/inventoryItems/query`, {
+        method: "POST",
+        headers: authHeaders({ "Content-Type": "application/json" }),
+        body: JSON.stringify({ query })
+      });
+      await assertOk(res, "queryInventory");
+      const json = await res.json();
+      return {
+        inventoryItems: json.inventoryItems ?? [],
+        totalResults: json.totalResults ?? 0
+      };
+    }
+  };
+}
+
+// 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];
+  if (!host || !prodEnvId || !token) {
+    const required = [
+      parameters5.host.slug,
+      parameters5.prodEnvId.slug,
+      parameters5.token.slug
+    ];
+    const missing = required.filter((s) => !params[s]);
+    throw new Error(
+      `dbt: missing required parameters: ${missing.join(", ")}`
+    );
+  }
+  const baseUrl = `https://${host.replace(/\/+$/, "")}`;
+  const environmentId = Number(prodEnvId);
+  function resolveGraphqlEndpoint() {
+    if (host.includes("emea")) return "https://metadata.emea.dbt.com/graphql";
+    if (host.includes(".au.")) return "https://metadata.au.dbt.com/graphql";
+    return "https://metadata.cloud.getdbt.com/graphql";
+  }
+  async function graphqlRequest(graphqlQuery, variables) {
+    const mergedVariables = {
+      environmentId,
+      ...variables
+    };
+    const response = await fetch(resolveGraphqlEndpoint(), {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${token}`
+      },
+      body: JSON.stringify({
+        query: graphqlQuery,
+        variables: mergedVariables
+      })
+    });
+    if (!response.ok) {
+      const body = await response.text().catch(() => "(unreadable body)");
+      throw new Error(
+        `dbt Discovery API error: ${response.status} ${response.statusText} \u2014 ${body}`
+      );
+    }
+    const json = await response.json();
+    if (json.errors && json.errors.length > 0) {
+      throw new Error(
+        `dbt GraphQL error: ${json.errors.map((e) => e.message).join("; ")}`
+      );
+    }
+    return json.data ?? {};
+  }
+  return {
+    request(path, init) {
+      const resolvedPath = path.replace(
+        /\{environmentId\}/g,
+        prodEnvId
+      );
+      const url = `${baseUrl}${resolvedPath}`;
+      const headers = new Headers(init?.headers);
+      headers.set("Authorization", `Bearer ${token}`);
+      return fetch(url, { ...init, headers });
+    },
+    query(graphqlQuery, variables) {
+      return graphqlRequest(graphqlQuery, variables);
+    },
+    async getModels(options) {
+      const first = options?.limit ?? 500;
+      const data = await graphqlRequest(
+        `query ($environmentId: BigInt!, $first: Int!) {
+          environment(id: $environmentId) {
+            applied {
+              models(first: $first) {
+                edges {
+                  node {
+                    uniqueId
+                    name
+                    description
+                    materializedType
+                    database
+                    schema
+                    alias
+                  }
+                }
+              }
+            }
+          }
+        }`,
+        { first }
+      );
+      const env = data.environment;
+      const applied = env?.applied;
+      const models = applied?.models;
+      const edges = models?.edges ?? [];
+      return edges.map((edge) => edge.node);
+    },
+    async getModelByUniqueId(uniqueId) {
+      const data = await graphqlRequest(
+        `query ($environmentId: BigInt!, $uniqueIds: [String!]) {
+          environment(id: $environmentId) {
+            applied {
+              models(first: 1, filter: { uniqueIds: $uniqueIds }) {
+                edges {
+                  node {
+                    uniqueId
+                    name
+                    description
+                    materializedType
+                    database
+                    schema
+                    alias
+                    catalog {
+                      columns {
+                        name
+                        type
+                        description
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }`,
+        { uniqueIds: [uniqueId] }
+      );
+      const env = data.environment;
+      const applied = env?.applied;
+      const models = applied?.models;
+      const edges = models?.edges ?? [];
+      return edges.length > 0 ? edges[0].node : null;
+    },
+    async getSources(options) {
+      const first = options?.limit ?? 500;
+      const data = await graphqlRequest(
+        `query ($environmentId: BigInt!, $first: Int!) {
+          environment(id: $environmentId) {
+            applied {
+              sources(first: $first) {
+                edges {
+                  node {
+                    uniqueId
+                    name
+                    description
+                    database
+                    schema
+                    identifier
+                    sourceName
+                    loader
+                    freshness {
+                      freshnessStatus
+                      maxLoadedAt
+                      freshnessChecked
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }`,
+        { first }
+      );
+      const env = data.environment;
+      const applied = env?.applied;
+      const sources = applied?.sources;
+      const edges = sources?.edges ?? [];
+      return edges.map((edge) => edge.node);
+    },
+    async getTests(options) {
+      const first = options?.limit ?? 500;
+      const data = await graphqlRequest(
+        `query ($environmentId: BigInt!, $first: Int!) {
+          environment(id: $environmentId) {
+            applied {
+              tests(first: $first) {
+                edges {
+                  node {
+                    uniqueId
+                    name
+                    columnName
+                    testType
+                    lastKnownResult
+                    executionInfo {
+                      lastRunStatus
+                      executionTime
+                      lastRunGeneratedAt
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }`,
+        { first }
+      );
+      const env = data.environment;
+      const applied = env?.applied;
+      const tests = applied?.tests;
+      const edges = tests?.edges ?? [];
+      return edges.map((edge) => edge.node);
+    },
+    async getMetrics(options) {
+      const first = options?.limit ?? 500;
+      const data = await graphqlRequest(
+        `query ($environmentId: BigInt!, $first: Int!) {
+          environment(id: $environmentId) {
+            definition {
+              metrics(first: $first) {
+                edges {
+                  node {
+                    uniqueId
+                    name
+                    description
+                    type
+                    label
+                    filter
+                    formula
+                  }
+                }
+              }
+            }
+          }
+        }`,
+        { first }
+      );
+      const env = data.environment;
+      const definition = env?.definition;
+      const metrics = definition?.metrics;
+      const edges = metrics?.edges ?? [];
+      return edges.map((edge) => edge.node);
+    }
+  };
+}
 export {
+  createClient3 as airtable,
+  createClient6 as dbt,
+  createClient4 as googleAnalytics,
   createClient as kintone,
-  createClient2 as openai
+  createClient2 as openai,
+  createClient5 as wixStore
 };