@squadbase/vite-server 0.0.1-build-10 → 0.0.1-build-12

package/dist/main.js

@@ -1,5 +1,6 @@
 // src/index.ts
 import { Hono as Hono5 } from "hono";
+import { contextStorage } from "hono/context-storage";
 import { cors } from "hono/cors";
 import path4 from "path";
 
@@ -68,6 +69,152 @@ function createBigQueryClient(entry, connectionId) {
   };
 }
 
+// src/connection.ts
+import { getContext } from "hono/context-storage";
+import { getCookie } from "hono/cookie";
+var APP_SESSION_COOKIE_NAME = "__Host-squadbase-session";
+var PREVIEW_SESSION_COOKIE_NAME = "squadbase-preview-session";
+var APP_BASE_DOMAIN = "squadbase.app";
+var PREVIEW_BASE_DOMAIN = "preview.app.squadbase.dev";
+var SANDBOX_ID_ENV_NAME = "INTERNAL_SQUADBASE_SANDBOX_ID";
+var MACHINE_CREDENTIAL_ENV_NAME = "INTERNAL_SQUADBASE_OAUTH_MACHINE_CREDENTIAL";
+function resolveProxyUrl(connectionId) {
+  const connectionPath = `/_sqcore/connections/${connectionId}/request`;
+  const sandboxId = process.env[SANDBOX_ID_ENV_NAME];
+  if (sandboxId) {
+    const baseDomain2 = process.env["SQUADBASE_PREVIEW_BASE_DOMAIN"] ?? PREVIEW_BASE_DOMAIN;
+    return `https://${sandboxId}.${baseDomain2}${connectionPath}`;
+  }
+  const projectId = process.env["SQUADBASE_PROJECT_ID"];
+  if (!projectId) {
+    throw new Error(
+      "Project ID is required. Please set SQUADBASE_PROJECT_ID environment variable."
+    );
+  }
+  const baseDomain = process.env["SQUADBASE_APP_BASE_DOMAIN"] ?? APP_BASE_DOMAIN;
+  return `https://${projectId}.${baseDomain}${connectionPath}`;
+}
+function resolveAuthHeaders() {
+  const machineCredential = process.env[MACHINE_CREDENTIAL_ENV_NAME];
+  if (machineCredential) {
+    return { Authorization: `Bearer ${machineCredential}` };
+  }
+  const c = getContext();
+  const cookies = getCookie(c);
+  const previewSession = cookies[PREVIEW_SESSION_COOKIE_NAME];
+  if (previewSession) {
+    return {
+      Cookie: `${PREVIEW_SESSION_COOKIE_NAME}=${previewSession}`
+    };
+  }
+  const appSession = cookies[APP_SESSION_COOKIE_NAME];
+  if (appSession) {
+    return { Authorization: `Bearer ${appSession}` };
+  }
+  throw new Error(
+    "No authentication method available for connection proxy. Expected one of: INTERNAL_SQUADBASE_OAUTH_MACHINE_CREDENTIAL env var, preview session cookie, or app session cookie."
+  );
+}
+function connection(connectionId) {
+  return {
+    async fetch(url, options) {
+      const proxyUrl = resolveProxyUrl(connectionId);
+      const authHeaders = resolveAuthHeaders();
+      return await fetch(proxyUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...authHeaders
+        },
+        body: JSON.stringify({
+          url,
+          method: options?.method,
+          headers: options?.headers,
+          body: options?.body,
+          timeoutMs: options?.timeoutMs
+        })
+      });
+    }
+  };
+}
+
+// src/connector-client/bigquery-oauth.ts
+var MAX_RESULTS = 1e4;
+var POLL_INTERVAL_MS = 1e3;
+var POLL_TIMEOUT_MS = 12e4;
+function flattenRows(fields, rows) {
+  return rows.map((row) => {
+    const obj = {};
+    for (let i = 0; i < fields.length; i++) {
+      obj[fields[i].name] = row.f[i].v;
+    }
+    return obj;
+  });
+}
+function createBigQueryOAuthClient(entry, connectionId) {
+  const projectId = resolveEnvVar(entry, "project-id", connectionId);
+  const baseUrl = `https://bigquery.googleapis.com/bigquery/v2/projects/${projectId}`;
+  return {
+    async query(sql) {
+      const conn = connection(connectionId);
+      const res = await conn.fetch(`${baseUrl}/queries`, {
+        method: "POST",
+        body: {
+          query: sql,
+          useLegacySql: false,
+          maxResults: MAX_RESULTS
+        }
+      });
+      if (!res.ok) {
+        const text = await res.text().catch(() => res.statusText);
+        throw new Error(`BigQuery query failed: HTTP ${res.status} ${text}`);
+      }
+      let data = await res.json();
+      if (data.errors?.length) {
+        throw new Error(
+          `BigQuery query error: ${data.errors.map((e) => e.message).join("; ")}`
+        );
+      }
+      if (!data.jobComplete) {
+        const jobId = data.jobReference.jobId;
+        const location = data.jobReference.location;
+        const deadline = Date.now() + POLL_TIMEOUT_MS;
+        while (!data.jobComplete) {
+          if (Date.now() > deadline) {
+            throw new Error(
+              `BigQuery query timed out after ${POLL_TIMEOUT_MS / 1e3}s (jobId: ${jobId})`
+            );
+          }
+          await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
+          const params = new URLSearchParams({
+            maxResults: String(MAX_RESULTS)
+          });
+          if (location) params.set("location", location);
+          const pollRes = await conn.fetch(
+            `${baseUrl}/queries/${jobId}?${params}`,
+            { method: "GET" }
+          );
+          if (!pollRes.ok) {
+            const text = await pollRes.text().catch(() => pollRes.statusText);
+            throw new Error(
+              `BigQuery poll failed: HTTP ${pollRes.status} ${text}`
+            );
+          }
+          data = await pollRes.json();
+          if (data.errors?.length) {
+            throw new Error(
+              `BigQuery query error: ${data.errors.map((e) => e.message).join("; ")}`
+            );
+          }
+        }
+      }
+      const fields = data.schema?.fields ?? [];
+      const rawRows = data.rows ?? [];
+      return { rows: flattenRows(fields, rawRows) };
+    }
+  };
+}
+
 // src/connector-client/snowflake.ts
 function createSnowflakeClient(entry, connectionId) {
   const accountIdentifier = resolveEnvVar(entry, "account", connectionId);
@@ -80,7 +227,7 @@ function createSnowflakeClient(entry, connectionId) {
     async query(sql) {
       const snowflake = (await import("snowflake-sdk")).default;
       snowflake.configure({ logLevel: "ERROR" });
-      const connection = snowflake.createConnection({
+      const connection2 = snowflake.createConnection({
         account: accountIdentifier,
         username: user,
         role,
@@ -89,13 +236,13 @@ function createSnowflakeClient(entry, connectionId) {
         privateKey
       });
       await new Promise((resolve, reject) => {
-        connection.connect((err) => {
+        connection2.connect((err) => {
           if (err) reject(new Error(`Snowflake connect failed: ${err.message}`));
           else resolve();
         });
       });
       const rows = await new Promise((resolve, reject) => {
-        connection.execute({
+        connection2.execute({
           sqlText: sql,
           complete: (err, _stmt, rows2) => {
             if (err) reject(new Error(`Snowflake query failed: ${err.message}`));
@@ -103,7 +250,7 @@ function createSnowflakeClient(entry, connectionId) {
           }
         });
       });
-      connection.destroy((err) => {
+      connection2.destroy((err) => {
         if (err) console.warn(`[connector-client] Snowflake destroy error: ${err.message}`);
       });
       return { rows };
@@ -309,6 +456,9 @@ function createConnectorRegistry() {
       return { client: createSnowflakeClient(entry, connectionId), connectorSlug };
     }
     if (connectorSlug === "bigquery") {
+      if (entry.connector.authType === "oauth") {
+        return { client: createBigQueryOAuthClient(entry, connectionId), connectorSlug };
+      }
       return { client: createBigQueryClient(entry, connectionId), connectorSlug };
     }
     if (connectorSlug === "athena") {
@@ -378,6 +528,68 @@ function createConnectorRegistry() {
 // src/connector-client/index.ts
 var { getClient, loadConnections, reloadEnvFile, watchConnectionsFile } = createConnectorRegistry();
 
+// src/types/data-source.ts
+import { z } from "zod";
+var parameterMetaSchema = z.object({
+  name: z.string(),
+  type: z.enum(["string", "number", "boolean"]),
+  description: z.string(),
+  required: z.boolean().optional(),
+  default: z.union([z.string(), z.number(), z.boolean()]).optional()
+});
+var dataSourceCacheConfigSchema = z.object({
+  ttl: z.number(),
+  staleWhileRevalidate: z.boolean().optional()
+});
+var dataSourceSchemaObjectSchema = z.lazy(
+  () => z.object({
+    type: z.enum(["string", "number", "integer", "boolean", "object", "array", "null"]).optional(),
+    format: z.string().optional(),
+    description: z.string().optional(),
+    nullable: z.boolean().optional(),
+    enum: z.array(z.union([z.string(), z.number(), z.boolean(), z.null()])).optional(),
+    items: dataSourceSchemaObjectSchema.optional(),
+    properties: z.record(z.string(), dataSourceSchemaObjectSchema).optional(),
+    required: z.array(z.string()).optional(),
+    additionalProperties: z.union([z.boolean(), dataSourceSchemaObjectSchema]).optional(),
+    minimum: z.number().optional(),
+    maximum: z.number().optional(),
+    minLength: z.number().optional(),
+    maxLength: z.number().optional(),
+    pattern: z.string().optional()
+  })
+);
+var dataSourceMediaTypeSchema = z.object({
+  schema: dataSourceSchemaObjectSchema.optional(),
+  example: z.unknown().optional()
+});
+var dataSourceResponseSchema = z.object({
+  description: z.string().optional(),
+  defaultContentType: z.string().optional(),
+  content: z.record(z.string(), dataSourceMediaTypeSchema).optional()
+});
+var jsonBaseFields = {
+  description: z.string(),
+  parameters: z.array(parameterMetaSchema).optional(),
+  response: dataSourceResponseSchema.optional(),
+  cache: dataSourceCacheConfigSchema.optional()
+};
+var jsonSqlDataSourceSchema = z.object({
+  ...jsonBaseFields,
+  type: z.literal("sql").optional(),
+  query: z.string(),
+  connectionId: z.string()
+});
+var jsonTypeScriptDataSourceSchema = z.object({
+  ...jsonBaseFields,
+  type: z.literal("typescript"),
+  handlerPath: z.string()
+});
+var anyJsonDataSourceSchema = z.union([
+  jsonTypeScriptDataSourceSchema,
+  jsonSqlDataSourceSchema
+]);
+
 // src/registry.ts
 var dataSources = /* @__PURE__ */ new Map();
 var currentDirPath = "";
@@ -443,26 +655,18 @@ async function initialize() {
     jsonFiles.map(async (file) => {
       const slug = file.replace(/\.json$/, "");
       const raw = await readFile2(`${dirPath}/${file}`, "utf-8");
-      const def = JSON.parse(raw);
-      if (!def.description) {
-        console.warn(`[registry] Skipping ${file}: missing description`);
-        return;
-      }
-      if (!def.connectionId) {
-        console.warn(`[registry] Skipping ${file}: missing connectionId`);
+      const parsed = anyJsonDataSourceSchema.safeParse(JSON.parse(raw));
+      if (!parsed.success) {
+        console.warn(`[registry] Skipping ${file}: ${parsed.error.message}`);
         return;
       }
+      const def = parsed.data;
       if (def.type === "typescript") {
-        if (!def.handlerPath) {
-          console.warn(`[registry] Skipping ${file}: missing handlerPath`);
-          return;
-        }
         const absoluteHandlerPath = validateHandlerPath(dirPath, def.handlerPath);
         const dataSourceDef = {
           description: def.description,
           parameters: def.parameters ?? [],
           response: def.response,
-          connectionId: def.connectionId,
           cacheConfig: def.cache,
           handler: async () => {
             throw new Error("TypeScript handler must be called via _tsHandlerPath");
@@ -474,10 +678,6 @@ async function initialize() {
         console.log(`[registry] registered (typescript): ${slug}`);
       } else {
         const sqlDef = def;
-        if (!sqlDef.query) {
-          console.warn(`[registry] Skipping ${file}: missing query`);
-          return;
-        }
         const dataSourceDef = {
           description: sqlDef.description,
           parameters: sqlDef.parameters ?? [],
@@ -567,17 +767,26 @@ function getDataSource(slug) {
   return dataSources.get(slug);
 }
 function buildMeta(slug, def) {
-  return {
+  const base = {
     slug,
     description: def.description,
-    type: def._isTypescript ? "typescript" : "sql",
     parameters: def.parameters,
     response: def.response,
-    query: def._query,
-    connectionId: def.connectionId,
-    handlerPath: def._tsHandlerPath ? path2.relative(currentDirPath, def._tsHandlerPath) : void 0,
     cache: def.cacheConfig
   };
+  if (def._isTypescript) {
+    return {
+      ...base,
+      type: "typescript",
+      handlerPath: path2.relative(currentDirPath, def._tsHandlerPath)
+    };
+  }
+  return {
+    ...base,
+    type: "sql",
+    connectionId: def.connectionId,
+    query: def._query
+  };
 }
 function getAllMeta() {
   return Array.from(dataSources.entries()).map(
@@ -915,6 +1124,7 @@ var pages_default = app4;
 
 // src/index.ts
 var apiApp = new Hono5();
+apiApp.use("/*", contextStorage());
 apiApp.use("/*", cors());
 apiApp.route("/data-source", data_source_default);
 apiApp.route("/data-source-meta", data_source_meta_default);

package/dist/types/data-source.d.ts

@@ -1,23 +1,23 @@
-interface ParameterMeta {
-    name: string;
-    type: "string" | "number" | "boolean";
-    description: string;
-    required?: boolean;
-    default?: string | number | boolean;
-}
-interface DataSourceCacheConfig {
-    /**
-     * Cache TTL in seconds.
-     * 0 or unset means no caching (default behavior for backward compatibility).
-     */
-    ttl: number;
-    /**
-     * When true, stale data is returned immediately after TTL expiry
-     * while fresh data is fetched asynchronously in the background to update the cache.
-     * Default: false
-     */
-    staleWhileRevalidate?: boolean;
-}
+import { z } from 'zod';
+
+declare const parameterMetaSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+    }>;
+    description: z.ZodString;
+    required: z.ZodOptional<z.ZodBoolean>;
+    default: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+}, z.core.$strip>;
+type ParameterMeta = z.infer<typeof parameterMetaSchema>;
+declare const dataSourceCacheConfigSchema: z.ZodObject<{
+    ttl: z.ZodNumber;
+    staleWhileRevalidate: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type DataSourceCacheConfig = z.infer<typeof dataSourceCacheConfigSchema>;
+declare const dataSourceSchemaObjectSchema: z.ZodType<DataSourceSchemaObject>;
 interface DataSourceSchemaObject {
     type?: "string" | "number" | "integer" | "boolean" | "object" | "array" | "null";
     format?: string;
@@ -34,55 +34,177 @@ interface DataSourceSchemaObject {
     maxLength?: number;
     pattern?: string;
 }
-interface DataSourceMediaType {
-    schema?: DataSourceSchemaObject;
-    example?: unknown;
-}
-interface DataSourceResponse {
-    description?: string;
-    defaultContentType?: string;
-    content?: Record<string, DataSourceMediaType>;
-}
-interface DataSourceDefinition {
+declare const dataSourceMediaTypeSchema: z.ZodObject<{
+    schema: z.ZodOptional<z.ZodType<DataSourceSchemaObject, unknown, z.core.$ZodTypeInternals<DataSourceSchemaObject, unknown>>>;
+    example: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+type DataSourceMediaType = z.infer<typeof dataSourceMediaTypeSchema>;
+declare const dataSourceResponseSchema: z.ZodObject<{
+    description: z.ZodOptional<z.ZodString>;
+    defaultContentType: z.ZodOptional<z.ZodString>;
+    content: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        schema: z.ZodOptional<z.ZodType<DataSourceSchemaObject, unknown, z.core.$ZodTypeInternals<DataSourceSchemaObject, unknown>>>;
+        example: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+type DataSourceResponse = z.infer<typeof dataSourceResponseSchema>;
+declare const jsonSqlDataSourceSchema: z.ZodObject<{
+    type: z.ZodOptional<z.ZodLiteral<"sql">>;
+    query: z.ZodString;
+    connectionId: z.ZodString;
+    description: z.ZodString;
+    parameters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+        }>;
+        description: z.ZodString;
+        required: z.ZodOptional<z.ZodBoolean>;
+        default: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+    }, z.core.$strip>>>;
+    response: z.ZodOptional<z.ZodObject<{
+        description: z.ZodOptional<z.ZodString>;
+        defaultContentType: z.ZodOptional<z.ZodString>;
+        content: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            schema: z.ZodOptional<z.ZodType<DataSourceSchemaObject, unknown, z.core.$ZodTypeInternals<DataSourceSchemaObject, unknown>>>;
+            example: z.ZodOptional<z.ZodUnknown>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    cache: z.ZodOptional<z.ZodObject<{
+        ttl: z.ZodNumber;
+        staleWhileRevalidate: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type JsonSqlDataSourceDefinition = z.infer<typeof jsonSqlDataSourceSchema>;
+declare const jsonTypeScriptDataSourceSchema: z.ZodObject<{
+    type: z.ZodLiteral<"typescript">;
+    handlerPath: z.ZodString;
+    description: z.ZodString;
+    parameters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+        }>;
+        description: z.ZodString;
+        required: z.ZodOptional<z.ZodBoolean>;
+        default: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+    }, z.core.$strip>>>;
+    response: z.ZodOptional<z.ZodObject<{
+        description: z.ZodOptional<z.ZodString>;
+        defaultContentType: z.ZodOptional<z.ZodString>;
+        content: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            schema: z.ZodOptional<z.ZodType<DataSourceSchemaObject, unknown, z.core.$ZodTypeInternals<DataSourceSchemaObject, unknown>>>;
+            example: z.ZodOptional<z.ZodUnknown>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    cache: z.ZodOptional<z.ZodObject<{
+        ttl: z.ZodNumber;
+        staleWhileRevalidate: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type JsonTypeScriptDataSourceDefinition = z.infer<typeof jsonTypeScriptDataSourceSchema>;
+declare const anyJsonDataSourceSchema: z.ZodUnion<readonly [z.ZodObject<{
+    type: z.ZodLiteral<"typescript">;
+    handlerPath: z.ZodString;
+    description: z.ZodString;
+    parameters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+        }>;
+        description: z.ZodString;
+        required: z.ZodOptional<z.ZodBoolean>;
+        default: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+    }, z.core.$strip>>>;
+    response: z.ZodOptional<z.ZodObject<{
+        description: z.ZodOptional<z.ZodString>;
+        defaultContentType: z.ZodOptional<z.ZodString>;
+        content: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            schema: z.ZodOptional<z.ZodType<DataSourceSchemaObject, unknown, z.core.$ZodTypeInternals<DataSourceSchemaObject, unknown>>>;
+            example: z.ZodOptional<z.ZodUnknown>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    cache: z.ZodOptional<z.ZodObject<{
+        ttl: z.ZodNumber;
+        staleWhileRevalidate: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodOptional<z.ZodLiteral<"sql">>;
+    query: z.ZodString;
+    connectionId: z.ZodString;
+    description: z.ZodString;
+    parameters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+        }>;
+        description: z.ZodString;
+        required: z.ZodOptional<z.ZodBoolean>;
+        default: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+    }, z.core.$strip>>>;
+    response: z.ZodOptional<z.ZodObject<{
+        description: z.ZodOptional<z.ZodString>;
+        defaultContentType: z.ZodOptional<z.ZodString>;
+        content: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            schema: z.ZodOptional<z.ZodType<DataSourceSchemaObject, unknown, z.core.$ZodTypeInternals<DataSourceSchemaObject, unknown>>>;
+            example: z.ZodOptional<z.ZodUnknown>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    cache: z.ZodOptional<z.ZodObject<{
+        ttl: z.ZodNumber;
+        staleWhileRevalidate: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>]>;
+type AnyJsonDataSourceDefinition = z.infer<typeof anyJsonDataSourceSchema>;
+interface BaseDataSourceDefinition {
     description: string;
     parameters: ParameterMeta[];
     response?: DataSourceResponse;
-    connectionId: string;
     cacheConfig?: DataSourceCacheConfig;
     handler: (params: Record<string, unknown>) => Promise<unknown> | unknown;
-    _isTypescript?: boolean;
-    _tsHandlerPath?: string;
-    _query?: string;
 }
-interface DataSourceMeta {
+interface SqlDataSourceDefinition extends BaseDataSourceDefinition {
+    connectionId: string;
+    _query: string;
+    _isTypescript?: false;
+    _tsHandlerPath?: undefined;
+}
+interface TypeScriptDataSourceDefinition extends BaseDataSourceDefinition {
+    _isTypescript: true;
+    _tsHandlerPath: string;
+    connectionId?: undefined;
+    _query?: undefined;
+}
+type DataSourceDefinition = SqlDataSourceDefinition | TypeScriptDataSourceDefinition;
+interface BaseDataSourceMeta {
     slug: string;
     description: string;
-    type: "sql" | "typescript";
     parameters: ParameterMeta[];
     response?: DataSourceResponse;
-    query?: string;
-    connectionId: string;
-    handlerPath?: string;
     cache?: DataSourceCacheConfig;
 }
-interface JsonDataSourceDefinition {
-    description: string;
-    type?: "sql";
-    parameters?: ParameterMeta[];
-    response?: DataSourceResponse;
-    query: string;
+interface SqlDataSourceMeta extends BaseDataSourceMeta {
+    type: "sql";
     connectionId: string;
-    cache?: DataSourceCacheConfig;
+    query: string;
+    handlerPath?: undefined;
 }
-interface JsonTypeScriptDataSourceDefinition {
-    description: string;
+interface TypeScriptDataSourceMeta extends BaseDataSourceMeta {
     type: "typescript";
     handlerPath: string;
-    connectionId: string;
-    parameters?: ParameterMeta[];
-    response?: DataSourceResponse;
-    cache?: DataSourceCacheConfig;
+    connectionId?: undefined;
+    query?: undefined;
 }
-type AnyJsonDataSourceDefinition = JsonDataSourceDefinition | JsonTypeScriptDataSourceDefinition;
+type DataSourceMeta = SqlDataSourceMeta | TypeScriptDataSourceMeta;
+/** @deprecated Use JsonSqlDataSourceDefinition */
+type JsonDataSourceDefinition = JsonSqlDataSourceDefinition;
 
-export type { AnyJsonDataSourceDefinition, DataSourceCacheConfig, DataSourceDefinition, DataSourceMediaType, DataSourceMeta, DataSourceResponse, DataSourceSchemaObject, JsonDataSourceDefinition, JsonTypeScriptDataSourceDefinition, ParameterMeta };
+export { type AnyJsonDataSourceDefinition, type DataSourceCacheConfig, type DataSourceDefinition, type DataSourceMediaType, type DataSourceMeta, type DataSourceResponse, type DataSourceSchemaObject, type JsonDataSourceDefinition, type JsonSqlDataSourceDefinition, type JsonTypeScriptDataSourceDefinition, type ParameterMeta, type SqlDataSourceDefinition, type SqlDataSourceMeta, type TypeScriptDataSourceDefinition, type TypeScriptDataSourceMeta, anyJsonDataSourceSchema, dataSourceCacheConfigSchema, dataSourceMediaTypeSchema, dataSourceResponseSchema, dataSourceSchemaObjectSchema, jsonSqlDataSourceSchema, jsonTypeScriptDataSourceSchema, parameterMetaSchema };

package/dist/types/data-source.js

@@ -0,0 +1,71 @@
+// src/types/data-source.ts
+import { z } from "zod";
+var parameterMetaSchema = z.object({
+  name: z.string(),
+  type: z.enum(["string", "number", "boolean"]),
+  description: z.string(),
+  required: z.boolean().optional(),
+  default: z.union([z.string(), z.number(), z.boolean()]).optional()
+});
+var dataSourceCacheConfigSchema = z.object({
+  ttl: z.number(),
+  staleWhileRevalidate: z.boolean().optional()
+});
+var dataSourceSchemaObjectSchema = z.lazy(
+  () => z.object({
+    type: z.enum(["string", "number", "integer", "boolean", "object", "array", "null"]).optional(),
+    format: z.string().optional(),
+    description: z.string().optional(),
+    nullable: z.boolean().optional(),
+    enum: z.array(z.union([z.string(), z.number(), z.boolean(), z.null()])).optional(),
+    items: dataSourceSchemaObjectSchema.optional(),
+    properties: z.record(z.string(), dataSourceSchemaObjectSchema).optional(),
+    required: z.array(z.string()).optional(),
+    additionalProperties: z.union([z.boolean(), dataSourceSchemaObjectSchema]).optional(),
+    minimum: z.number().optional(),
+    maximum: z.number().optional(),
+    minLength: z.number().optional(),
+    maxLength: z.number().optional(),
+    pattern: z.string().optional()
+  })
+);
+var dataSourceMediaTypeSchema = z.object({
+  schema: dataSourceSchemaObjectSchema.optional(),
+  example: z.unknown().optional()
+});
+var dataSourceResponseSchema = z.object({
+  description: z.string().optional(),
+  defaultContentType: z.string().optional(),
+  content: z.record(z.string(), dataSourceMediaTypeSchema).optional()
+});
+var jsonBaseFields = {
+  description: z.string(),
+  parameters: z.array(parameterMetaSchema).optional(),
+  response: dataSourceResponseSchema.optional(),
+  cache: dataSourceCacheConfigSchema.optional()
+};
+var jsonSqlDataSourceSchema = z.object({
+  ...jsonBaseFields,
+  type: z.literal("sql").optional(),
+  query: z.string(),
+  connectionId: z.string()
+});
+var jsonTypeScriptDataSourceSchema = z.object({
+  ...jsonBaseFields,
+  type: z.literal("typescript"),
+  handlerPath: z.string()
+});
+var anyJsonDataSourceSchema = z.union([
+  jsonTypeScriptDataSourceSchema,
+  jsonSqlDataSourceSchema
+]);
+export {
+  anyJsonDataSourceSchema,
+  dataSourceCacheConfigSchema,
+  dataSourceMediaTypeSchema,
+  dataSourceResponseSchema,
+  dataSourceSchemaObjectSchema,
+  jsonSqlDataSourceSchema,
+  jsonTypeScriptDataSourceSchema,
+  parameterMetaSchema
+};