@squadbase/vite-server 0.0.1-build-1

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

@@ -0,0 +1,83 @@
+interface ParameterMeta {
+    name: string;
+    type: "string" | "number" | "boolean";
+    description: string;
+    required?: boolean;
+    default?: string | number | boolean;
+}
+interface DataSourceCacheConfig {
+    /**
+     * キャッシュの有効期間（秒）。
+     * 0 または未指定の場合はキャッシュしない（後方互換性を保つデフォルト動作）。
+     */
+    ttl: number;
+    /**
+     * true の場合、TTL 期限切れ後も古いデータを即座に返しつつ、
+     * バックグラウンドで新しいデータを非同期取得してキャッシュを更新する。
+     * デフォルト: false
+     */
+    staleWhileRevalidate?: boolean;
+}
+interface DataSourceSchemaObject {
+    type?: "string" | "number" | "integer" | "boolean" | "object" | "array" | "null";
+    format?: string;
+    description?: string;
+    nullable?: boolean;
+    enum?: (string | number | boolean | null)[];
+    items?: DataSourceSchemaObject;
+    properties?: Record<string, DataSourceSchemaObject>;
+    required?: string[];
+    additionalProperties?: boolean | DataSourceSchemaObject;
+    minimum?: number;
+    maximum?: number;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+}
+interface DataSourceMediaType {
+    schema?: DataSourceSchemaObject;
+    example?: unknown;
+}
+interface DataSourceResponse {
+    description?: string;
+    defaultContentType?: string;
+    content?: Record<string, DataSourceMediaType>;
+}
+interface DataSourceDefinition {
+    description: string;
+    parameters: ParameterMeta[];
+    response?: DataSourceResponse;
+    connectorSlug?: string;
+    cacheConfig?: DataSourceCacheConfig;
+    handler: (params: Record<string, unknown>) => Promise<unknown> | unknown;
+    _isTypescript?: boolean;
+    _tsHandlerPath?: string;
+}
+interface DataSourceMeta {
+    slug: string;
+    description: string;
+    parameters: ParameterMeta[];
+    response?: DataSourceResponse;
+    connectorSlug?: string;
+}
+interface JsonDataSourceDefinition {
+    description: string;
+    type?: "sql";
+    parameters?: ParameterMeta[];
+    response?: DataSourceResponse;
+    query: string;
+    connectorType?: string;
+    connectorSlug?: string;
+    cache?: DataSourceCacheConfig;
+}
+interface JsonTypeScriptDataSourceDefinition {
+    description: string;
+    type: "typescript";
+    handlerPath: string;
+    parameters?: ParameterMeta[];
+    response?: DataSourceResponse;
+    cache?: DataSourceCacheConfig;
+}
+type AnyJsonDataSourceDefinition = JsonDataSourceDefinition | JsonTypeScriptDataSourceDefinition;
+
+export type { AnyJsonDataSourceDefinition, DataSourceCacheConfig, DataSourceDefinition, DataSourceMediaType, DataSourceMeta, DataSourceResponse, DataSourceSchemaObject, JsonDataSourceDefinition, JsonTypeScriptDataSourceDefinition, ParameterMeta };

package/dist/vite-plugin.d.ts

@@ -0,0 +1,12 @@
+import { Plugin } from 'vite';
+
+interface SquadbasePluginOptions {
+    buildEntry?: string;
+    devEntry?: string;
+    port?: number;
+    external?: string[];
+    exclude?: RegExp[];
+}
+declare function squadbasePlugin(options?: SquadbasePluginOptions): Plugin[];
+
+export { squadbasePlugin };

package/dist/vite-plugin.js

@@ -0,0 +1,267 @@
+// src/vite-plugin.ts
+import buildPlugin from "@hono/vite-build/node";
+import devServer from "@hono/vite-dev-server";
+import nodeAdapter from "@hono/vite-dev-server/node";
+
+// src/registry.ts
+import { readdir, readFile, mkdir } from "fs/promises";
+import { watch as fsWatch2 } from "fs";
+import path2 from "path";
+
+// src/connector-client/registry.ts
+import { readFileSync, watch as fsWatch } from "fs";
+import path from "path";
+
+// src/connector-client/postgresql.ts
+import pg from "pg";
+var { Pool } = pg;
+function createPostgreSQLClient(connectionString) {
+  const pool = new Pool({ connectionString, ssl: { rejectUnauthorized: false } });
+  return {
+    async query(sql, params) {
+      const result = await pool.query(sql, params);
+      return { rows: result.rows };
+    }
+  };
+}
+
+// src/connector-client/env.ts
+function resolveEnvVar(entry, key, slug) {
+  const envVarName = entry.envVars[key];
+  if (!envVarName) {
+    throw new Error(`Connector "${slug}" is missing envVars mapping for key "${key}"`);
+  }
+  const value = process.env[envVarName];
+  if (!value) {
+    throw new Error(`Environment variable "${envVarName}" (for "${slug}.${key}") is not set`);
+  }
+  return value;
+}
+
+// src/connector-client/bigquery.ts
+function createBigQueryClient(entry, slug) {
+  const projectId = resolveEnvVar(entry, "project-id", slug);
+  const serviceAccountJsonBase64 = resolveEnvVar(entry, "service-account-json-base64", slug);
+  const serviceAccountJson = Buffer.from(serviceAccountJsonBase64, "base64").toString("utf-8");
+  let gcpCredentials;
+  try {
+    gcpCredentials = JSON.parse(serviceAccountJson);
+  } catch {
+    throw new Error(
+      `BigQuery service account JSON (decoded from base64) is not valid JSON for slug "${slug}"`
+    );
+  }
+  return {
+    async query(sql) {
+      const { BigQuery } = await import("@google-cloud/bigquery");
+      const bq = new BigQuery({ projectId, credentials: gcpCredentials });
+      const [job] = await bq.createQueryJob({ query: sql });
+      const [allRows] = await job.getQueryResults({ timeoutMs: 3e4 });
+      return { rows: allRows };
+    }
+  };
+}
+
+// src/connector-client/snowflake.ts
+function createSnowflakeClient(entry, slug) {
+  const accountIdentifier = resolveEnvVar(entry, "account", slug);
+  const user = resolveEnvVar(entry, "user", slug);
+  const role = resolveEnvVar(entry, "role", slug);
+  const warehouse = resolveEnvVar(entry, "warehouse", slug);
+  const privateKeyBase64 = resolveEnvVar(entry, "private-key-base64", slug);
+  const privateKey = Buffer.from(privateKeyBase64, "base64").toString("utf-8");
+  return {
+    async query(sql) {
+      const snowflake = (await import("snowflake-sdk")).default;
+      snowflake.configure({ logLevel: "ERROR" });
+      const connection = snowflake.createConnection({
+        account: accountIdentifier,
+        username: user,
+        role,
+        warehouse,
+        authenticator: "SNOWFLAKE_JWT",
+        privateKey
+      });
+      await new Promise((resolve, reject) => {
+        connection.connect((err) => {
+          if (err) reject(new Error(`Snowflake connect failed: ${err.message}`));
+          else resolve();
+        });
+      });
+      const rows = await new Promise((resolve, reject) => {
+        connection.execute({
+          sqlText: sql,
+          complete: (err, _stmt, rows2) => {
+            if (err) reject(new Error(`Snowflake query failed: ${err.message}`));
+            else resolve(rows2 ?? []);
+          }
+        });
+      });
+      connection.destroy((err) => {
+        if (err) console.warn(`[connector-client] Snowflake destroy error: ${err.message}`);
+      });
+      return { rows };
+    }
+  };
+}
+
+// src/connector-client/registry.ts
+function createConnectorRegistry() {
+  let connectionsCache = null;
+  const clientCache = /* @__PURE__ */ new Map();
+  function getConnectionsFilePath() {
+    return process.env.CONNECTIONS_PATH ?? path.join(process.cwd(), "../../.squadbase/connections.json");
+  }
+  function loadConnections() {
+    if (connectionsCache !== null) return connectionsCache;
+    const filePath = getConnectionsFilePath();
+    try {
+      const raw = readFileSync(filePath, "utf-8");
+      connectionsCache = JSON.parse(raw);
+    } catch {
+      connectionsCache = {};
+    }
+    return connectionsCache;
+  }
+  async function getClient2(connectorSlug, connectorType) {
+    if (!connectorSlug) {
+      const cacheKey = "__squadbase-db__";
+      const cached2 = clientCache.get(cacheKey);
+      if (cached2) return cached2;
+      const url = process.env.SQUADBASE_POSTGRESQL_URL;
+      if (!url) throw new Error("SQUADBASE_POSTGRESQL_URL environment variable is not set");
+      const client = createPostgreSQLClient(url);
+      clientCache.set(cacheKey, client);
+      return client;
+    }
+    const cached = clientCache.get(connectorSlug);
+    if (cached) return cached;
+    const connections = loadConnections();
+    const entry = connections[connectorSlug];
+    if (!entry) {
+      throw new Error(`connector slug '${connectorSlug}' not found in .squadbase/connections.json`);
+    }
+    const resolvedType = connectorType ?? entry.connectorType;
+    if (!resolvedType) {
+      throw new Error(
+        `connector type could not be determined for slug '${connectorSlug}'. Specify connectorType in the data-source JSON or in .squadbase/connections.json.`
+      );
+    }
+    if (resolvedType === "snowflake") {
+      return createSnowflakeClient(entry, connectorSlug);
+    }
+    if (resolvedType === "bigquery") {
+      return createBigQueryClient(entry, connectorSlug);
+    }
+    if (resolvedType === "postgresql" || resolvedType === "squadbase-db") {
+      const urlEnvName = entry.envVars["connection-url"];
+      if (!urlEnvName) {
+        throw new Error(`'connection-url' is not defined in envVars for connector '${connectorSlug}'`);
+      }
+      const connectionUrl = process.env[urlEnvName];
+      if (!connectionUrl) {
+        throw new Error(
+          `environment variable '${urlEnvName}' (mapped from connector '${connectorSlug}') is not set`
+        );
+      }
+      const client = createPostgreSQLClient(connectionUrl);
+      clientCache.set(connectorSlug, client);
+      return client;
+    }
+    throw new Error(
+      `connector type '${resolvedType}' is not supported. Supported: "snowflake", "bigquery", "postgresql", "squadbase-db"`
+    );
+  }
+  function reloadEnvFile2(envPath) {
+    try {
+      const raw = readFileSync(envPath, "utf-8");
+      for (const line of raw.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#")) continue;
+        const eqIdx = trimmed.indexOf("=");
+        if (eqIdx === -1) continue;
+        const key = trimmed.slice(0, eqIdx).trim();
+        const value = trimmed.slice(eqIdx + 1).trim();
+        if (key) process.env[key] = value;
+      }
+      console.log("[connector-client] .env reloaded");
+    } catch {
+    }
+  }
+  function watchConnectionsFile2() {
+    const filePath = getConnectionsFilePath();
+    const envPath = path.join(process.cwd(), "..", "..", ".env");
+    try {
+      fsWatch(filePath, { persistent: false }, () => {
+        console.log("[connector-client] connections.json changed, clearing cache");
+        connectionsCache = null;
+        clientCache.clear();
+        setImmediate(() => reloadEnvFile2(envPath));
+      });
+    } catch {
+    }
+  }
+  return { getClient: getClient2, reloadEnvFile: reloadEnvFile2, watchConnectionsFile: watchConnectionsFile2 };
+}
+
+// src/connector-client/index.ts
+var { getClient, reloadEnvFile, watchConnectionsFile } = createConnectorRegistry();
+
+// src/registry.ts
+var viteServer = null;
+function setViteServer(server) {
+  viteServer = server;
+}
+var defaultDataSourceDir = path2.join(process.cwd(), "data-source");
+
+// src/vite-plugin.ts
+var DEFAULT_EXCLUDE = [
+  /.*\.css$/,
+  /.*\.ts$/,
+  /.*\.tsx$/,
+  /^\/@.+$/,
+  /\?t\=\d+$/,
+  /^\/favicon\.ico$/,
+  /^\/static\/.+/,
+  /^\/node_modules\/.*/,
+  /^(?!\/api)/
+];
+function squadbasePlugin(options = {}) {
+  const {
+    buildEntry = "@squadbase/vite-server/main",
+    devEntry = "@squadbase/vite-server",
+    port = 3285,
+    external = ["pg", "@google-cloud/bigquery", "snowflake-sdk"],
+    exclude = DEFAULT_EXCLUDE
+  } = options;
+  const isServerBuild = (_, { command, mode }) => command === "build" && mode !== "client";
+  const rawBuildPlugin = buildPlugin({
+    entry: buildEntry,
+    outputDir: "./dist/server",
+    output: "index.js",
+    port,
+    external
+  });
+  const rawDevServerPlugin = devServer({
+    entry: devEntry,
+    adapter: nodeAdapter,
+    exclude
+  });
+  const buildPlugins = (Array.isArray(rawBuildPlugin) ? rawBuildPlugin : [rawBuildPlugin]).map(
+    (p) => ({ ...p, apply: isServerBuild })
+  );
+  const devPlugins = (Array.isArray(rawDevServerPlugin) ? rawDevServerPlugin : [rawDevServerPlugin]).map(
+    (p) => ({ ...p, apply: "serve" })
+  );
+  const viteServerInjectionPlugin = {
+    name: "squadbase-vite-server-injection",
+    apply: "serve",
+    configureServer(server) {
+      setViteServer(server);
+    }
+  };
+  return [...buildPlugins, ...devPlugins, viteServerInjectionPlugin];
+}
+export {
+  squadbasePlugin
+};

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@squadbase/vite-server",
+  "version": "0.0.1-build-1",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./main": {
+      "import": "./dist/main.js",
+      "types": "./dist/main.d.ts"
+    },
+    "./types": {
+      "import": "./dist/types/data-source.js",
+      "types": "./dist/types/data-source.d.ts"
+    },
+    "./plugin": {
+      "import": "./dist/vite-plugin.js",
+      "types": "./dist/vite-plugin.d.ts"
+    }
+  },
+  "files": ["dist"],
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "squadbase-ds-test": "./dist/cli/index.js"
+  },
+  "scripts": {
+    "cli": "tsx src/cli/index.ts",
+    "build": "tsup && pnpm run build:cli",
+    "build:cli": "tsup src/cli/index.ts --out-dir dist/cli --format esm --platform node --no-splitting --external pg --external snowflake-sdk --external @google-cloud/bigquery --external hono --external @clack/prompts"
+  },
+  "dependencies": {
+    "@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": "^4.11.9",
+    "pg": "^8.18.0",
+    "snowflake-sdk": "^1.15.0"
+  },
+  "devDependencies": {
+    "@clack/prompts": "^0.9.1",
+    "@types/node": "^22.15.0",
+    "@types/pg": "^8.16.0",
+    "@types/snowflake-sdk": "^1.6.24",
+    "tsup": "^8.4.0",
+    "tsx": "^4.19.3",
+    "typescript": "~5.7.0",
+    "vite": "^6.0.0"
+  }
+}