@squadbase/vite-server 0.0.1-build-9 → 0.0.1-build-11

package/dist/cli/index.js

@@ -469,6 +469,70 @@ import path3 from "path";
 import { readdir, readFile as readFile2, mkdir } from "fs/promises";
 import { watch as fsWatch2 } from "fs";
 import path2 from "path";
+
+// 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
 function buildQuery(queryTemplate, parameterMeta, runtimeParams) {
   const defaults = new Map(
     parameterMeta.map((p) => [p.name, p.default ?? null])
@@ -605,7 +669,17 @@ async function runDataSource(slug, dirPath, params, limit) {
   let def;
   try {
     const raw = await readFile3(jsonPath, "utf-8");
-    def = JSON.parse(raw);
+    const parsed = anyJsonDataSourceSchema.safeParse(JSON.parse(raw));
+    if (!parsed.success) {
+      return {
+        slug,
+        rows: [],
+        rowCount: 0,
+        durationMs: 0,
+        error: new Error(`Invalid data source definition: ${parsed.error.message}`)
+      };
+    }
+    def = parsed.data;
   } catch {
     return {
       slug,
@@ -811,8 +885,8 @@ Total: ${results.length}, Failed: ${failed}`);
       let paramMeta = [];
       try {
         const raw = await readFile4(jsonPath, "utf-8");
-        const def = JSON.parse(raw);
-        paramMeta = def.parameters ?? [];
+        const parsed = anyJsonDataSourceSchema.safeParse(JSON.parse(raw));
+        if (parsed.success) paramMeta = parsed.data.parameters ?? [];
       } catch {
       }
       const interactiveParams = await inputParameters2(paramMeta);

package/dist/index.d.ts

@@ -126,6 +126,16 @@ declare const getClient: (connectionId: string) => Promise<{
 }>;
 declare const loadConnections: () => Promise<ConnectionsMap>;
 
+type ConnectionFetchOptions = {
+    method?: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+    headers?: Record<string, string>;
+    body?: unknown;
+    timeoutMs?: number;
+};
+declare function connection(connectionId: string): {
+    fetch(url: string, options?: ConnectionFetchOptions): Promise<Response>;
+};
+
 declare const app: Hono<hono_types.BlankEnv, hono_types.BlankSchema, "/">;
 
-export { type AirtableClient, type AirtableRecord, type ConnectionEntry, type ConnectionsMap, type DatabaseClient, type DbtClient, type GoogleAnalyticsClient, type KintoneClient, type WixStoreClient, createAirtableClient, createDbtClient, createGoogleAnalyticsClient, createKintoneClient, createWixStoreClient, app as default, getClient, loadConnections };
+export { type AirtableClient, type AirtableRecord, type ConnectionEntry, type ConnectionFetchOptions, type ConnectionsMap, type DatabaseClient, type DbtClient, type GoogleAnalyticsClient, type KintoneClient, type WixStoreClient, connection, createAirtableClient, createDbtClient, createGoogleAnalyticsClient, createKintoneClient, createWixStoreClient, app as default, getClient, loadConnections };

package/dist/index.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";
 
@@ -80,7 +81,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 +90,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 +104,7 @@ function createSnowflakeClient(entry, connectionId) {
           }
         });
       });
-      connection.destroy((err) => {
+      connection2.destroy((err) => {
         if (err) console.warn(`[connector-client] Snowflake destroy error: ${err.message}`);
       });
       return { rows };
@@ -640,6 +641,68 @@ function createDbtClient(entry, slug) {
 // 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 = "";
@@ -705,26 +768,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");
@@ -736,10 +791,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 ?? [],
@@ -829,17 +880,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(
@@ -1175,8 +1235,78 @@ app4.get("/runtime-data", (c) => {
 });
 var pages_default = app4;
 
+// 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/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);
@@ -1191,6 +1321,7 @@ app5.get("/healthz", (c) => c.json({ status: "ok" }));
 app5.route("/api", apiApp);
 var src_default = app5;
 export {
+  connection,
   createAirtableClient,
   createDbtClient,
   createGoogleAnalyticsClient,

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";
 
@@ -80,7 +81,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 +90,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 +104,7 @@ function createSnowflakeClient(entry, connectionId) {
           }
         });
       });
-      connection.destroy((err) => {
+      connection2.destroy((err) => {
         if (err) console.warn(`[connector-client] Snowflake destroy error: ${err.message}`);
       });
       return { rows };
@@ -378,6 +379,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 +506,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 +529,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 +618,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(
@@ -913,8 +973,13 @@ app4.get("/runtime-data", (c) => {
 });
 var pages_default = app4;
 
+// src/connection.ts
+import { getContext } from "hono/context-storage";
+import { getCookie } from "hono/cookie";
+
 // 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
+};

package/dist/vite-plugin.d.ts

@@ -3,7 +3,6 @@ import { Plugin } from 'vite';
 interface SquadbasePluginOptions {
     buildEntry?: string;
     devEntry?: string;
-    port?: number;
     external?: string[];
     exclude?: RegExp[];
 }

package/dist/vite-plugin.js

@@ -380,6 +380,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 viteServer = null;
 function setViteServer(server) {
@@ -414,8 +476,17 @@ function squadbasePlugin(options = {}) {
   const {
     buildEntry = "@squadbase/vite-server/main",
     devEntry = "@squadbase/vite-server",
-    port = 3285,
-    external = ["pg", "@google-cloud/bigquery", "snowflake-sdk"],
+    external = [
+      "pg",
+      "@google-cloud/bigquery",
+      "snowflake-sdk",
+      "mysql2",
+      "@databricks/sql",
+      "@aws-sdk/client-athena",
+      "@aws-sdk/client-redshift-data",
+      "@google-analytics/data",
+      "@kintone/rest-api-client"
+    ],
     exclude = DEFAULT_EXCLUDE
   } = options;
   const isServerBuild = (_, { command, mode }) => command === "build" && mode !== "client";
@@ -423,7 +494,6 @@ function squadbasePlugin(options = {}) {
     entry: resolveEntry(buildEntry),
     outputDir: "./dist/server",
     output: "index.js",
-    port,
     external
   });
   const rawDevServerPlugin = devServer({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@squadbase/vite-server",
-  "version": "0.0.1-build-9",
+  "version": "0.0.1-build-11",
   "type": "module",
   "exports": {
     ".": {
@@ -42,12 +42,13 @@
     "@google-cloud/bigquery": "^7.9.4",
     "@hono/node-server": "^1.19.9",
     "@hono/vite-build": "^1.10.0",
-    "@hono/vite-dev-server": "^0.18.0",
+    "@hono/vite-dev-server": "^0.25.0",
     "@kintone/rest-api-client": "^5.5.0",
     "hono": "^4.11.9",
     "mysql2": "^3.11.0",
     "pg": "^8.18.0",
-    "snowflake-sdk": "^1.15.0"
+    "snowflake-sdk": "^1.15.0",
+    "zod": "^4.3.6"
   },
   "devDependencies": {
     "@clack/prompts": "^0.9.1",
@@ -57,6 +58,6 @@
     "tsup": "^8.4.0",
     "tsx": "^4.19.3",
     "typescript": "~5.7.0",
-    "vite": "^6.0.0"
+    "vite": "^7.0.0"
   }
 }