@squadbase/vite-server 0.0.8 → 0.0.10

package/dist/cli/index.js

@@ -14,7 +14,7 @@ var interactive_exports = {};
 __export(interactive_exports, {
   confirmRunAll: () => confirmRunAll,
   inputParameters: () => inputParameters,
-  selectDataSource: () => selectDataSource
+  selectServerLogic: () => selectServerLogic
 });
 async function getPrompts() {
   try {
@@ -26,10 +26,10 @@ async function getPrompts() {
     );
   }
 }
-async function selectDataSource(slugs) {
+async function selectServerLogic(slugs) {
   const { select, isCancel } = await getPrompts();
   const result = await select({
-    message: "Select a data source to test:",
+    message: "Select a server logic to test:",
     options: slugs.map((s) => ({ value: s, label: s }))
   });
   if (isCancel(result)) return null;
@@ -68,7 +68,7 @@ async function inputParameters(params) {
 async function confirmRunAll() {
   const { confirm, isCancel } = await getPrompts();
   const result = await confirm({
-    message: "Run all data sources?"
+    message: "Run all server logics?"
   });
   if (isCancel(result)) return false;
   return result;
@@ -280,7 +280,7 @@ import { readdir, readFile as readFile2, mkdir } from "fs/promises";
 import { watch as fsWatch2 } from "fs";
 import path2 from "path";
 
-// src/types/data-source.ts
+// src/types/server-logic.ts
 import { z } from "zod";
 var parameterMetaSchema = z.object({
   name: z.string(),
@@ -289,21 +289,21 @@ var parameterMetaSchema = z.object({
   required: z.boolean().optional(),
   default: z.union([z.string(), z.number(), z.boolean()]).optional()
 });
-var dataSourceCacheConfigSchema = z.object({
+var serverLogicCacheConfigSchema = z.object({
   ttl: z.number(),
   staleWhileRevalidate: z.boolean().optional()
 });
-var dataSourceSchemaObjectSchema = z.lazy(
+var serverLogicSchemaObjectSchema = 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(),
+    items: serverLogicSchemaObjectSchema.optional(),
+    properties: z.record(z.string(), serverLogicSchemaObjectSchema).optional(),
     required: z.array(z.string()).optional(),
-    additionalProperties: z.union([z.boolean(), dataSourceSchemaObjectSchema]).optional(),
+    additionalProperties: z.union([z.boolean(), serverLogicSchemaObjectSchema]).optional(),
     minimum: z.number().optional(),
     maximum: z.number().optional(),
     minLength: z.number().optional(),
@@ -311,34 +311,34 @@ var dataSourceSchemaObjectSchema = z.lazy(
     pattern: z.string().optional()
   })
 );
-var dataSourceMediaTypeSchema = z.object({
-  schema: dataSourceSchemaObjectSchema.optional(),
+var serverLogicMediaTypeSchema = z.object({
+  schema: serverLogicSchemaObjectSchema.optional(),
   example: z.unknown().optional()
 });
-var dataSourceResponseSchema = z.object({
+var serverLogicResponseSchema = z.object({
   description: z.string().optional(),
-  content: z.record(z.string(), dataSourceMediaTypeSchema).optional()
+  content: z.record(z.string(), serverLogicMediaTypeSchema).optional()
 });
 var jsonBaseFields = {
   description: z.string(),
   parameters: z.array(parameterMetaSchema).optional(),
-  response: dataSourceResponseSchema.optional(),
-  cache: dataSourceCacheConfigSchema.optional()
+  response: serverLogicResponseSchema.optional(),
+  cache: serverLogicCacheConfigSchema.optional()
 };
-var jsonSqlDataSourceSchema = z.object({
+var jsonSqlServerLogicSchema = z.object({
   ...jsonBaseFields,
   type: z.literal("sql").optional(),
   query: z.string(),
   connectionId: z.string()
 });
-var jsonTypeScriptDataSourceSchema = z.object({
+var jsonTypeScriptServerLogicSchema = z.object({
   ...jsonBaseFields,
   type: z.literal("typescript"),
   handlerPath: z.string()
 });
-var anyJsonDataSourceSchema = z.union([
-  jsonTypeScriptDataSourceSchema,
-  jsonSqlDataSourceSchema
+var anyJsonServerLogicSchema = z.union([
+  jsonTypeScriptServerLogicSchema,
+  jsonSqlServerLogicSchema
 ]);
 
 // src/registry.ts
@@ -357,7 +357,7 @@ function applyDefaults(parameterMeta, runtimeParams) {
   }
   return result;
 }
-var defaultDataSourceDir = path2.join(process.cwd(), "data-source");
+var defaultServerLogicDir = path2.join(process.cwd(), "server-logic");
 
 // src/cli/runner.ts
 function createStubContext(params) {
@@ -388,7 +388,7 @@ function createStubContext(params) {
   };
   return stub;
 }
-async function runSqlDataSource(slug, def, params, limit) {
+async function runSqlServerLogic(slug, def, params, limit) {
   const start = Date.now();
   try {
     const query = await getQuery(def.connectionId);
@@ -412,7 +412,7 @@ async function runSqlDataSource(slug, def, params, limit) {
     };
   }
 }
-async function runTypescriptDataSource(slug, handlerPath, params) {
+async function runTypescriptServerLogic(slug, handlerPath, params) {
   const start = Date.now();
   try {
     const mod = await import(pathToFileURL(handlerPath).href);
@@ -446,19 +446,19 @@ async function runTypescriptDataSource(slug, handlerPath, params) {
     };
   }
 }
-async function runDataSource(slug, dirPath, params, limit) {
+async function runServerLogic(slug, dirPath, params, limit) {
   const jsonPath = path3.join(dirPath, `${slug}.json`);
   let def;
   try {
     const raw = await readFile3(jsonPath, "utf-8");
-    const parsed = anyJsonDataSourceSchema.safeParse(JSON.parse(raw));
+    const parsed = anyJsonServerLogicSchema.safeParse(JSON.parse(raw));
     if (!parsed.success) {
       return {
         slug,
         rows: [],
         rowCount: 0,
         durationMs: 0,
-        error: new Error(`Invalid data source definition: ${parsed.error.message}`)
+        error: new Error(`Invalid server logic definition: ${parsed.error.message}`)
       };
     }
     def = parsed.data;
@@ -468,14 +468,14 @@ async function runDataSource(slug, dirPath, params, limit) {
       rows: [],
       rowCount: 0,
       durationMs: 0,
-      error: new Error(`Data source not found: ${jsonPath}`)
+      error: new Error(`Server logic not found: ${jsonPath}`)
     };
   }
   if (def.type === "typescript") {
     const absolutePath = path3.resolve(dirPath, def.handlerPath);
-    return runTypescriptDataSource(slug, absolutePath, params);
+    return runTypescriptServerLogic(slug, absolutePath, params);
   }
-  return runSqlDataSource(slug, def, params, limit);
+  return runSqlServerLogic(slug, def, params, limit);
 }
 async function listSlugs(dirPath) {
   try {
@@ -487,7 +487,7 @@ async function listSlugs(dirPath) {
 }
 async function runAll(dirPath, params, limit) {
   const slugs = await listSlugs(dirPath);
-  return Promise.all(slugs.map((slug) => runDataSource(slug, dirPath, params, limit)));
+  return Promise.all(slugs.map((slug) => runServerLogic(slug, dirPath, params, limit)));
 }
 
 // src/cli/display.ts
@@ -570,14 +570,14 @@ function displayError(error) {
 
 // src/cli/index.ts
 var HELP = `
-Usage: squadbase-ds-test [options]
+Usage: squadbase-sl-test [options]
 
 Options:
-  --slug <slug>     Run a specific data source
-  --all             Run all data sources
+  --slug <slug>     Run a specific server logic
+  --all             Run all server logics
   --params k=v,...  Comma-separated key=value parameters
   --env <path>      Path to .env file (default: ../../.env)
-  --dir <path>      Data source directory (default: ./data-source)
+  --dir <path>      Server logic directory (default: ./server-logic)
   --format table|json  Output format (default: table)
   --limit <n>       Max rows to display (default: 50)
   --debug           Show SQL query and parameter values
@@ -609,7 +609,7 @@ async function main() {
     process.exit(0);
   }
   const cwd = process.cwd();
-  const dirPath = values.dir ? path4.resolve(cwd, values.dir) : path4.join(cwd, "data-source");
+  const dirPath = values.dir ? path4.resolve(cwd, values.dir) : path4.join(cwd, "server-logic");
   const envPath = values.env ? path4.resolve(cwd, values.env) : path4.join(cwd, "../../.env");
   const limit = parseInt(values.limit ?? "50", 10);
   const format = values.format ?? "table";
@@ -625,7 +625,7 @@ async function main() {
     }
   }
   if (values.slug) {
-    const result = await runDataSource(values.slug, dirPath, params, limit);
+    const result = await runServerLogic(values.slug, dirPath, params, limit);
     if (format === "json") {
       displayJson([result]);
     } else {
@@ -653,12 +653,12 @@ Total: ${results.length}, Failed: ${failed}`);
   } else {
     const slugs = await listSlugs(dirPath);
     if (slugs.length === 0) {
-      displayError(new Error(`No data sources found in ${dirPath}`));
+      displayError(new Error(`No server logics found in ${dirPath}`));
       process.exit(1);
     }
     try {
-      const { selectDataSource: selectDataSource2, inputParameters: inputParameters2 } = await Promise.resolve().then(() => (init_interactive(), interactive_exports));
-      const slug = await selectDataSource2(slugs);
+      const { selectServerLogic: selectServerLogic2, inputParameters: inputParameters2 } = await Promise.resolve().then(() => (init_interactive(), interactive_exports));
+      const slug = await selectServerLogic2(slugs);
       if (!slug) {
         console.log("Cancelled.");
         process.exit(0);
@@ -667,13 +667,13 @@ Total: ${results.length}, Failed: ${failed}`);
       let paramMeta = [];
       try {
         const raw = await readFile4(jsonPath, "utf-8");
-        const parsed = anyJsonDataSourceSchema.safeParse(JSON.parse(raw));
+        const parsed = anyJsonServerLogicSchema.safeParse(JSON.parse(raw));
         if (parsed.success) paramMeta = parsed.data.parameters ?? [];
       } catch {
       }
       const interactiveParams = await inputParameters2(paramMeta);
       const merged = { ...interactiveParams, ...params };
-      const result = await runDataSource(slug, dirPath, merged, limit);
+      const result = await runServerLogic(slug, dirPath, merged, limit);
       displaySummary(result);
       if (values.debug) displayDebug(result);
       if (!result.error) displayTable(result.rows, limit);

package/dist/index.js

@@ -451,7 +451,7 @@ function createDbtClient(entry, slug) {
 // src/connector-client/index.ts
 var { getQuery, loadConnections, reloadEnvFile, watchConnectionsFile } = createConnectorRegistry();
 
-// src/types/data-source.ts
+// src/types/server-logic.ts
 import { z } from "zod";
 var parameterMetaSchema = z.object({
   name: z.string(),
@@ -460,21 +460,21 @@ var parameterMetaSchema = z.object({
   required: z.boolean().optional(),
   default: z.union([z.string(), z.number(), z.boolean()]).optional()
 });
-var dataSourceCacheConfigSchema = z.object({
+var serverLogicCacheConfigSchema = z.object({
   ttl: z.number(),
   staleWhileRevalidate: z.boolean().optional()
 });
-var dataSourceSchemaObjectSchema = z.lazy(
+var serverLogicSchemaObjectSchema = 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(),
+    items: serverLogicSchemaObjectSchema.optional(),
+    properties: z.record(z.string(), serverLogicSchemaObjectSchema).optional(),
     required: z.array(z.string()).optional(),
-    additionalProperties: z.union([z.boolean(), dataSourceSchemaObjectSchema]).optional(),
+    additionalProperties: z.union([z.boolean(), serverLogicSchemaObjectSchema]).optional(),
     minimum: z.number().optional(),
     maximum: z.number().optional(),
     minLength: z.number().optional(),
@@ -482,45 +482,45 @@ var dataSourceSchemaObjectSchema = z.lazy(
     pattern: z.string().optional()
   })
 );
-var dataSourceMediaTypeSchema = z.object({
-  schema: dataSourceSchemaObjectSchema.optional(),
+var serverLogicMediaTypeSchema = z.object({
+  schema: serverLogicSchemaObjectSchema.optional(),
   example: z.unknown().optional()
 });
-var dataSourceResponseSchema = z.object({
+var serverLogicResponseSchema = z.object({
   description: z.string().optional(),
-  content: z.record(z.string(), dataSourceMediaTypeSchema).optional()
+  content: z.record(z.string(), serverLogicMediaTypeSchema).optional()
 });
 var jsonBaseFields = {
   description: z.string(),
   parameters: z.array(parameterMetaSchema).optional(),
-  response: dataSourceResponseSchema.optional(),
-  cache: dataSourceCacheConfigSchema.optional()
+  response: serverLogicResponseSchema.optional(),
+  cache: serverLogicCacheConfigSchema.optional()
 };
-var jsonSqlDataSourceSchema = z.object({
+var jsonSqlServerLogicSchema = z.object({
   ...jsonBaseFields,
   type: z.literal("sql").optional(),
   query: z.string(),
   connectionId: z.string()
 });
-var jsonTypeScriptDataSourceSchema = z.object({
+var jsonTypeScriptServerLogicSchema = z.object({
   ...jsonBaseFields,
   type: z.literal("typescript"),
   handlerPath: z.string()
 });
-var anyJsonDataSourceSchema = z.union([
-  jsonTypeScriptDataSourceSchema,
-  jsonSqlDataSourceSchema
+var anyJsonServerLogicSchema = z.union([
+  jsonTypeScriptServerLogicSchema,
+  jsonSqlServerLogicSchema
 ]);
 
 // src/registry.ts
-var dataSources = /* @__PURE__ */ new Map();
+var serverLogics = /* @__PURE__ */ new Map();
 var currentDirPath = "";
 var viteServer = null;
 function validateHandlerPath(dirPath, handlerPath) {
   const absolute = path2.resolve(dirPath, handlerPath);
   const normalizedDir = path2.resolve(dirPath);
   if (!absolute.startsWith(normalizedDir + path2.sep)) {
-    throw new Error(`Handler path escapes data-source directory: ${handlerPath}`);
+    throw new Error(`Handler path escapes server-logic directory: ${handlerPath}`);
   }
   if (!absolute.endsWith(".ts")) {
     throw new Error(`Handler must be a .ts file: ${handlerPath}`);
@@ -558,13 +558,13 @@ function applyDefaults(parameterMeta, runtimeParams) {
   }
   return result;
 }
-var defaultDataSourceDir = path2.join(process.cwd(), "data-source");
+var defaultServerLogicDir = path2.join(process.cwd(), "server-logic");
 async function initialize() {
   console.log(
-    `[registry] loading data sources from ${defaultDataSourceDir}...`
+    `[registry] loading server logics from ${defaultServerLogicDir}...`
   );
-  dataSources.clear();
-  const dirPath = process.env.DATA_SOURCE_DIR || defaultDataSourceDir;
+  serverLogics.clear();
+  const dirPath = process.env.SERVER_LOGIC_DIR || process.env.DATA_SOURCE_DIR || defaultServerLogicDir;
   currentDirPath = dirPath;
   await mkdir(dirPath, { recursive: true });
   const files = await readdir(dirPath);
@@ -573,7 +573,7 @@ async function initialize() {
     jsonFiles.map(async (file) => {
       const slug = file.replace(/\.json$/, "");
       const raw = await readFile2(`${dirPath}/${file}`, "utf-8");
-      const parsed = anyJsonDataSourceSchema.safeParse(JSON.parse(raw));
+      const parsed = anyJsonServerLogicSchema.safeParse(JSON.parse(raw));
       if (!parsed.success) {
         console.warn(`[registry] Skipping ${file}: ${parsed.error.message}`);
         return;
@@ -581,7 +581,7 @@ async function initialize() {
       const def = parsed.data;
       if (def.type === "typescript") {
         const absoluteHandlerPath = validateHandlerPath(dirPath, def.handlerPath);
-        const dataSourceDef = {
+        const serverLogicDef = {
           description: def.description,
           parameters: def.parameters ?? [],
           response: def.response,
@@ -592,11 +592,11 @@ async function initialize() {
           _isTypescript: true,
           _tsHandlerPath: absoluteHandlerPath
         };
-        dataSources.set(slug, dataSourceDef);
+        serverLogics.set(slug, serverLogicDef);
         console.log(`[registry] registered (typescript): ${slug}`);
       } else {
         const sqlDef = def;
-        const dataSourceDef = {
+        const serverLogicDef = {
           description: sqlDef.description,
           parameters: sqlDef.parameters ?? [],
           response: sqlDef.response,
@@ -613,7 +613,7 @@ async function initialize() {
             return result.rows;
           }
         };
-        dataSources.set(slug, dataSourceDef);
+        serverLogics.set(slug, serverLogicDef);
         console.log(`[registry] registered: ${slug}`);
       }
     })
@@ -626,29 +626,29 @@ async function initialize() {
       );
     }
   });
-  console.log(`[registry] ${dataSources.size} data source(s) ready`);
+  console.log(`[registry] ${serverLogics.size} server logic(s) ready`);
 }
 var reloadTimer = null;
 function startWatching() {
-  const dirPath = process.env.DATA_SOURCE_DIR || defaultDataSourceDir;
+  const dirPath = process.env.SERVER_LOGIC_DIR || process.env.DATA_SOURCE_DIR || defaultServerLogicDir;
   try {
     fsWatch2(dirPath, { persistent: false }, (_event, filename) => {
       if (!filename?.endsWith(".json") && !filename?.endsWith(".ts")) return;
       if (reloadTimer) clearTimeout(reloadTimer);
       reloadTimer = setTimeout(async () => {
-        console.log("[registry] data-source changed, reloading...");
+        console.log("[registry] server-logic changed, reloading...");
         await initialize();
       }, 300);
     });
-    console.log("[registry] watching data-source directory");
+    console.log("[registry] watching server-logic directory");
   } catch {
     console.warn(
-      "[registry] could not watch data-source directory (static load only)"
+      "[registry] could not watch server-logic directory (static load only)"
     );
   }
 }
-function getDataSource(slug) {
-  return dataSources.get(slug);
+function getServerLogic(slug) {
+  return serverLogics.get(slug);
 }
 function buildMeta(slug, def) {
   const base = {
@@ -673,17 +673,17 @@ function buildMeta(slug, def) {
   };
 }
 function getAllMeta() {
-  return Array.from(dataSources.entries()).map(
+  return Array.from(serverLogics.entries()).map(
     ([slug, def]) => buildMeta(slug, def)
   );
 }
 function getMeta(slug) {
-  const def = dataSources.get(slug);
+  const def = serverLogics.get(slug);
   if (!def) return void 0;
   return buildMeta(slug, def);
 }
 
-// src/routes/data-source.ts
+// src/routes/server-logic.ts
 import { Hono } from "hono";
 
 // src/cache.ts
@@ -776,7 +776,7 @@ function buildCacheKey(slug, params) {
   return `${slug}:${JSON.stringify(sortedParams)}`;
 }
 
-// src/routes/data-source.ts
+// src/routes/server-logic.ts
 var app = new Hono();
 function buildSqlResponse(c, result) {
   return c.json({ data: result });
@@ -786,9 +786,9 @@ function buildTypescriptResponse(result) {
 }
 app.get("/:slug", async (c) => {
   const slug = c.req.param("slug");
-  const ds = getDataSource(slug);
+  const ds = getServerLogic(slug);
   if (!ds) {
-    return c.json({ error: `Data source '${slug}' not found` }, 404);
+    return c.json({ error: `Server logic '${slug}' not found` }, 404);
   }
   try {
     if (ds._isTypescript && ds._tsHandlerPath) {
@@ -800,7 +800,7 @@ app.get("/:slug", async (c) => {
       return buildSqlResponse(c, result);
     }
   } catch (e) {
-    console.error(`[data-source] ${slug} error:`, e);
+    console.error(`[server-logic] ${slug} error:`, e);
     return c.json(
       { error: e instanceof Error ? e.message : "Internal error" },
       500
@@ -809,9 +809,9 @@ app.get("/:slug", async (c) => {
 });
 app.post("/:slug", async (c) => {
   const slug = c.req.param("slug");
-  const ds = getDataSource(slug);
+  const ds = getServerLogic(slug);
   if (!ds) {
-    return c.json({ error: `Data source '${slug}' not found` }, 404);
+    return c.json({ error: `Server logic '${slug}' not found` }, 404);
   }
   try {
     const body = await c.req.json().catch(() => ({}));
@@ -877,16 +877,16 @@ app.post("/:slug", async (c) => {
     c.header("Cache-Control", `max-age=${ttl}`);
     return buildResponse(result);
   } catch (e) {
-    console.error(`[data-source] ${slug} error:`, e);
+    console.error(`[server-logic] ${slug} error:`, e);
     return c.json(
       { error: e instanceof Error ? e.message : "Internal error" },
       500
     );
   }
 });
-var data_source_default = app;
+var server_logic_default = app;
 
-// src/routes/data-source-meta.ts
+// src/routes/server-logic-meta.ts
 import { Hono as Hono2 } from "hono";
 var app2 = new Hono2();
 app2.get("/", (c) => {
@@ -896,11 +896,11 @@ app2.get("/:slug", (c) => {
   const slug = c.req.param("slug");
   const meta = getMeta(slug);
   if (!meta) {
-    return c.json({ error: `Data source '${slug}' not found` }, 404);
+    return c.json({ error: `Server logic '${slug}' not found` }, 404);
   }
   return c.json(meta);
 });
-var data_source_meta_default = app2;
+var server_logic_meta_default = app2;
 
 // src/routes/cache.ts
 import { Hono as Hono3 } from "hono";
@@ -1060,8 +1060,8 @@ function connection(connectionId) {
 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);
+apiApp.route("/server-logic", server_logic_default);
+apiApp.route("/server-logic-meta", server_logic_meta_default);
 apiApp.route("/cache", cache_default);
 apiApp.route("/", pages_default);
 reloadEnvFile(path4.join(process.cwd(), ".env"));

package/dist/main.js

@@ -189,7 +189,7 @@ function resolveParams(entry, connectionId, plugin) {
 // src/connector-client/index.ts
 var { getQuery, loadConnections, reloadEnvFile, watchConnectionsFile } = createConnectorRegistry();
 
-// src/types/data-source.ts
+// src/types/server-logic.ts
 import { z } from "zod";
 var parameterMetaSchema = z.object({
   name: z.string(),
@@ -198,21 +198,21 @@ var parameterMetaSchema = z.object({
   required: z.boolean().optional(),
   default: z.union([z.string(), z.number(), z.boolean()]).optional()
 });
-var dataSourceCacheConfigSchema = z.object({
+var serverLogicCacheConfigSchema = z.object({
   ttl: z.number(),
   staleWhileRevalidate: z.boolean().optional()
 });
-var dataSourceSchemaObjectSchema = z.lazy(
+var serverLogicSchemaObjectSchema = 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(),
+    items: serverLogicSchemaObjectSchema.optional(),
+    properties: z.record(z.string(), serverLogicSchemaObjectSchema).optional(),
     required: z.array(z.string()).optional(),
-    additionalProperties: z.union([z.boolean(), dataSourceSchemaObjectSchema]).optional(),
+    additionalProperties: z.union([z.boolean(), serverLogicSchemaObjectSchema]).optional(),
     minimum: z.number().optional(),
     maximum: z.number().optional(),
     minLength: z.number().optional(),
@@ -220,45 +220,45 @@ var dataSourceSchemaObjectSchema = z.lazy(
     pattern: z.string().optional()
   })
 );
-var dataSourceMediaTypeSchema = z.object({
-  schema: dataSourceSchemaObjectSchema.optional(),
+var serverLogicMediaTypeSchema = z.object({
+  schema: serverLogicSchemaObjectSchema.optional(),
   example: z.unknown().optional()
 });
-var dataSourceResponseSchema = z.object({
+var serverLogicResponseSchema = z.object({
   description: z.string().optional(),
-  content: z.record(z.string(), dataSourceMediaTypeSchema).optional()
+  content: z.record(z.string(), serverLogicMediaTypeSchema).optional()
 });
 var jsonBaseFields = {
   description: z.string(),
   parameters: z.array(parameterMetaSchema).optional(),
-  response: dataSourceResponseSchema.optional(),
-  cache: dataSourceCacheConfigSchema.optional()
+  response: serverLogicResponseSchema.optional(),
+  cache: serverLogicCacheConfigSchema.optional()
 };
-var jsonSqlDataSourceSchema = z.object({
+var jsonSqlServerLogicSchema = z.object({
   ...jsonBaseFields,
   type: z.literal("sql").optional(),
   query: z.string(),
   connectionId: z.string()
 });
-var jsonTypeScriptDataSourceSchema = z.object({
+var jsonTypeScriptServerLogicSchema = z.object({
   ...jsonBaseFields,
   type: z.literal("typescript"),
   handlerPath: z.string()
 });
-var anyJsonDataSourceSchema = z.union([
-  jsonTypeScriptDataSourceSchema,
-  jsonSqlDataSourceSchema
+var anyJsonServerLogicSchema = z.union([
+  jsonTypeScriptServerLogicSchema,
+  jsonSqlServerLogicSchema
 ]);
 
 // src/registry.ts
-var dataSources = /* @__PURE__ */ new Map();
+var serverLogics = /* @__PURE__ */ new Map();
 var currentDirPath = "";
 var viteServer = null;
 function validateHandlerPath(dirPath, handlerPath) {
   const absolute = path2.resolve(dirPath, handlerPath);
   const normalizedDir = path2.resolve(dirPath);
   if (!absolute.startsWith(normalizedDir + path2.sep)) {
-    throw new Error(`Handler path escapes data-source directory: ${handlerPath}`);
+    throw new Error(`Handler path escapes server-logic directory: ${handlerPath}`);
   }
   if (!absolute.endsWith(".ts")) {
     throw new Error(`Handler must be a .ts file: ${handlerPath}`);
@@ -296,13 +296,13 @@ function applyDefaults(parameterMeta, runtimeParams) {
   }
   return result;
 }
-var defaultDataSourceDir = path2.join(process.cwd(), "data-source");
+var defaultServerLogicDir = path2.join(process.cwd(), "server-logic");
 async function initialize() {
   console.log(
-    `[registry] loading data sources from ${defaultDataSourceDir}...`
+    `[registry] loading server logics from ${defaultServerLogicDir}...`
   );
-  dataSources.clear();
-  const dirPath = process.env.DATA_SOURCE_DIR || defaultDataSourceDir;
+  serverLogics.clear();
+  const dirPath = process.env.SERVER_LOGIC_DIR || process.env.DATA_SOURCE_DIR || defaultServerLogicDir;
   currentDirPath = dirPath;
   await mkdir(dirPath, { recursive: true });
   const files = await readdir(dirPath);
@@ -311,7 +311,7 @@ async function initialize() {
     jsonFiles.map(async (file) => {
       const slug = file.replace(/\.json$/, "");
       const raw = await readFile2(`${dirPath}/${file}`, "utf-8");
-      const parsed = anyJsonDataSourceSchema.safeParse(JSON.parse(raw));
+      const parsed = anyJsonServerLogicSchema.safeParse(JSON.parse(raw));
       if (!parsed.success) {
         console.warn(`[registry] Skipping ${file}: ${parsed.error.message}`);
         return;
@@ -319,7 +319,7 @@ async function initialize() {
       const def = parsed.data;
       if (def.type === "typescript") {
         const absoluteHandlerPath = validateHandlerPath(dirPath, def.handlerPath);
-        const dataSourceDef = {
+        const serverLogicDef = {
           description: def.description,
           parameters: def.parameters ?? [],
           response: def.response,
@@ -330,11 +330,11 @@ async function initialize() {
           _isTypescript: true,
           _tsHandlerPath: absoluteHandlerPath
         };
-        dataSources.set(slug, dataSourceDef);
+        serverLogics.set(slug, serverLogicDef);
         console.log(`[registry] registered (typescript): ${slug}`);
       } else {
         const sqlDef = def;
-        const dataSourceDef = {
+        const serverLogicDef = {
           description: sqlDef.description,
           parameters: sqlDef.parameters ?? [],
           response: sqlDef.response,
@@ -351,7 +351,7 @@ async function initialize() {
             return result.rows;
           }
         };
-        dataSources.set(slug, dataSourceDef);
+        serverLogics.set(slug, serverLogicDef);
         console.log(`[registry] registered: ${slug}`);
       }
     })
@@ -364,29 +364,29 @@ async function initialize() {
       );
     }
   });
-  console.log(`[registry] ${dataSources.size} data source(s) ready`);
+  console.log(`[registry] ${serverLogics.size} server logic(s) ready`);
 }
 var reloadTimer = null;
 function startWatching() {
-  const dirPath = process.env.DATA_SOURCE_DIR || defaultDataSourceDir;
+  const dirPath = process.env.SERVER_LOGIC_DIR || process.env.DATA_SOURCE_DIR || defaultServerLogicDir;
   try {
     fsWatch2(dirPath, { persistent: false }, (_event, filename) => {
       if (!filename?.endsWith(".json") && !filename?.endsWith(".ts")) return;
       if (reloadTimer) clearTimeout(reloadTimer);
       reloadTimer = setTimeout(async () => {
-        console.log("[registry] data-source changed, reloading...");
+        console.log("[registry] server-logic changed, reloading...");
         await initialize();
       }, 300);
     });
-    console.log("[registry] watching data-source directory");
+    console.log("[registry] watching server-logic directory");
   } catch {
     console.warn(
-      "[registry] could not watch data-source directory (static load only)"
+      "[registry] could not watch server-logic directory (static load only)"
     );
   }
 }
-function getDataSource(slug) {
-  return dataSources.get(slug);
+function getServerLogic(slug) {
+  return serverLogics.get(slug);
 }
 function buildMeta(slug, def) {
   const base = {
@@ -411,17 +411,17 @@ function buildMeta(slug, def) {
   };
 }
 function getAllMeta() {
-  return Array.from(dataSources.entries()).map(
+  return Array.from(serverLogics.entries()).map(
     ([slug, def]) => buildMeta(slug, def)
   );
 }
 function getMeta(slug) {
-  const def = dataSources.get(slug);
+  const def = serverLogics.get(slug);
   if (!def) return void 0;
   return buildMeta(slug, def);
 }
 
-// src/routes/data-source.ts
+// src/routes/server-logic.ts
 import { Hono } from "hono";
 
 // src/cache.ts
@@ -514,7 +514,7 @@ function buildCacheKey(slug, params) {
   return `${slug}:${JSON.stringify(sortedParams)}`;
 }
 
-// src/routes/data-source.ts
+// src/routes/server-logic.ts
 var app = new Hono();
 function buildSqlResponse(c, result) {
   return c.json({ data: result });
@@ -524,9 +524,9 @@ function buildTypescriptResponse(result) {
 }
 app.get("/:slug", async (c) => {
   const slug = c.req.param("slug");
-  const ds = getDataSource(slug);
+  const ds = getServerLogic(slug);
   if (!ds) {
-    return c.json({ error: `Data source '${slug}' not found` }, 404);
+    return c.json({ error: `Server logic '${slug}' not found` }, 404);
   }
   try {
     if (ds._isTypescript && ds._tsHandlerPath) {
@@ -538,7 +538,7 @@ app.get("/:slug", async (c) => {
       return buildSqlResponse(c, result);
     }
   } catch (e) {
-    console.error(`[data-source] ${slug} error:`, e);
+    console.error(`[server-logic] ${slug} error:`, e);
     return c.json(
       { error: e instanceof Error ? e.message : "Internal error" },
       500
@@ -547,9 +547,9 @@ app.get("/:slug", async (c) => {
 });
 app.post("/:slug", async (c) => {
   const slug = c.req.param("slug");
-  const ds = getDataSource(slug);
+  const ds = getServerLogic(slug);
   if (!ds) {
-    return c.json({ error: `Data source '${slug}' not found` }, 404);
+    return c.json({ error: `Server logic '${slug}' not found` }, 404);
   }
   try {
     const body = await c.req.json().catch(() => ({}));
@@ -615,16 +615,16 @@ app.post("/:slug", async (c) => {
     c.header("Cache-Control", `max-age=${ttl}`);
     return buildResponse(result);
   } catch (e) {
-    console.error(`[data-source] ${slug} error:`, e);
+    console.error(`[server-logic] ${slug} error:`, e);
     return c.json(
       { error: e instanceof Error ? e.message : "Internal error" },
       500
     );
   }
 });
-var data_source_default = app;
+var server_logic_default = app;
 
-// src/routes/data-source-meta.ts
+// src/routes/server-logic-meta.ts
 import { Hono as Hono2 } from "hono";
 var app2 = new Hono2();
 app2.get("/", (c) => {
@@ -634,11 +634,11 @@ app2.get("/:slug", (c) => {
   const slug = c.req.param("slug");
   const meta = getMeta(slug);
   if (!meta) {
-    return c.json({ error: `Data source '${slug}' not found` }, 404);
+    return c.json({ error: `Server logic '${slug}' not found` }, 404);
   }
   return c.json(meta);
 });
-var data_source_meta_default = app2;
+var server_logic_meta_default = app2;
 
 // src/routes/cache.ts
 import { Hono as Hono3 } from "hono";
@@ -733,8 +733,8 @@ import { getCookie as getCookie2 } from "hono/cookie";
 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);
+apiApp.route("/server-logic", server_logic_default);
+apiApp.route("/server-logic-meta", server_logic_meta_default);
 apiApp.route("/cache", cache_default);
 apiApp.route("/", pages_default);
 reloadEnvFile(path4.join(process.cwd(), ".env"));

package/dist/types/{data-source.d.ts → server-logic.d.ts}

@@ -12,42 +12,42 @@ declare const parameterMetaSchema: z.ZodObject<{
     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<{
+declare const serverLogicCacheConfigSchema: 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 ServerLogicCacheConfig = z.infer<typeof serverLogicCacheConfigSchema>;
+declare const serverLogicSchemaObjectSchema: z.ZodType<ServerLogicSchemaObject>;
+interface ServerLogicSchemaObject {
     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>;
+    items?: ServerLogicSchemaObject;
+    properties?: Record<string, ServerLogicSchemaObject>;
     required?: string[];
-    additionalProperties?: boolean | DataSourceSchemaObject;
+    additionalProperties?: boolean | ServerLogicSchemaObject;
     minimum?: number;
     maximum?: number;
     minLength?: number;
     maxLength?: number;
     pattern?: string;
 }
-declare const dataSourceMediaTypeSchema: z.ZodObject<{
-    schema: z.ZodOptional<z.ZodType<DataSourceSchemaObject, unknown, z.core.$ZodTypeInternals<DataSourceSchemaObject, unknown>>>;
+declare const serverLogicMediaTypeSchema: z.ZodObject<{
+    schema: z.ZodOptional<z.ZodType<ServerLogicSchemaObject, unknown, z.core.$ZodTypeInternals<ServerLogicSchemaObject, unknown>>>;
     example: z.ZodOptional<z.ZodUnknown>;
 }, z.core.$strip>;
-type DataSourceMediaType = z.infer<typeof dataSourceMediaTypeSchema>;
-declare const dataSourceResponseSchema: z.ZodObject<{
+type ServerLogicMediaType = z.infer<typeof serverLogicMediaTypeSchema>;
+declare const serverLogicResponseSchema: z.ZodObject<{
     description: 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>>>;
+        schema: z.ZodOptional<z.ZodType<ServerLogicSchemaObject, unknown, z.core.$ZodTypeInternals<ServerLogicSchemaObject, unknown>>>;
         example: z.ZodOptional<z.ZodUnknown>;
     }, z.core.$strip>>>;
 }, z.core.$strip>;
-type DataSourceResponse = z.infer<typeof dataSourceResponseSchema>;
-declare const jsonSqlDataSourceSchema: z.ZodObject<{
+type ServerLogicResponse = z.infer<typeof serverLogicResponseSchema>;
+declare const jsonSqlServerLogicSchema: z.ZodObject<{
     type: z.ZodOptional<z.ZodLiteral<"sql">>;
     query: z.ZodString;
     connectionId: z.ZodString;
@@ -66,7 +66,7 @@ declare const jsonSqlDataSourceSchema: z.ZodObject<{
     response: z.ZodOptional<z.ZodObject<{
         description: 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>>>;
+            schema: z.ZodOptional<z.ZodType<ServerLogicSchemaObject, unknown, z.core.$ZodTypeInternals<ServerLogicSchemaObject, unknown>>>;
             example: z.ZodOptional<z.ZodUnknown>;
         }, z.core.$strip>>>;
     }, z.core.$strip>>;
@@ -75,8 +75,8 @@ declare const jsonSqlDataSourceSchema: z.ZodObject<{
         staleWhileRevalidate: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
-type JsonSqlDataSourceDefinition = z.infer<typeof jsonSqlDataSourceSchema>;
-declare const jsonTypeScriptDataSourceSchema: z.ZodObject<{
+type JsonSqlServerLogicDefinition = z.infer<typeof jsonSqlServerLogicSchema>;
+declare const jsonTypeScriptServerLogicSchema: z.ZodObject<{
     type: z.ZodLiteral<"typescript">;
     handlerPath: z.ZodString;
     description: z.ZodString;
@@ -94,7 +94,7 @@ declare const jsonTypeScriptDataSourceSchema: z.ZodObject<{
     response: z.ZodOptional<z.ZodObject<{
         description: 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>>>;
+            schema: z.ZodOptional<z.ZodType<ServerLogicSchemaObject, unknown, z.core.$ZodTypeInternals<ServerLogicSchemaObject, unknown>>>;
             example: z.ZodOptional<z.ZodUnknown>;
         }, z.core.$strip>>>;
     }, z.core.$strip>>;
@@ -103,8 +103,8 @@ declare const jsonTypeScriptDataSourceSchema: z.ZodObject<{
         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 JsonTypeScriptServerLogicDefinition = z.infer<typeof jsonTypeScriptServerLogicSchema>;
+declare const anyJsonServerLogicSchema: z.ZodUnion<readonly [z.ZodObject<{
     type: z.ZodLiteral<"typescript">;
     handlerPath: z.ZodString;
     description: z.ZodString;
@@ -122,7 +122,7 @@ declare const anyJsonDataSourceSchema: z.ZodUnion<readonly [z.ZodObject<{
     response: z.ZodOptional<z.ZodObject<{
         description: 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>>>;
+            schema: z.ZodOptional<z.ZodType<ServerLogicSchemaObject, unknown, z.core.$ZodTypeInternals<ServerLogicSchemaObject, unknown>>>;
             example: z.ZodOptional<z.ZodUnknown>;
         }, z.core.$strip>>>;
     }, z.core.$strip>>;
@@ -149,7 +149,7 @@ declare const anyJsonDataSourceSchema: z.ZodUnion<readonly [z.ZodObject<{
     response: z.ZodOptional<z.ZodObject<{
         description: 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>>>;
+            schema: z.ZodOptional<z.ZodType<ServerLogicSchemaObject, unknown, z.core.$ZodTypeInternals<ServerLogicSchemaObject, unknown>>>;
             example: z.ZodOptional<z.ZodUnknown>;
         }, z.core.$strip>>>;
     }, z.core.$strip>>;
@@ -158,48 +158,48 @@ declare const anyJsonDataSourceSchema: z.ZodUnion<readonly [z.ZodObject<{
         staleWhileRevalidate: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
 }, z.core.$strip>]>;
-type AnyJsonDataSourceDefinition = z.infer<typeof anyJsonDataSourceSchema>;
-interface BaseDataSourceDefinition {
+type AnyJsonServerLogicDefinition = z.infer<typeof anyJsonServerLogicSchema>;
+interface BaseServerLogicDefinition {
     description: string;
     parameters: ParameterMeta[];
-    response?: DataSourceResponse;
-    cacheConfig?: DataSourceCacheConfig;
+    response?: ServerLogicResponse;
+    cacheConfig?: ServerLogicCacheConfig;
     handler: (params: Record<string, unknown>) => Promise<unknown> | unknown;
 }
-interface SqlDataSourceDefinition extends BaseDataSourceDefinition {
+interface SqlServerLogicDefinition extends BaseServerLogicDefinition {
     connectionId: string;
     _query: string;
     _isTypescript?: false;
     _tsHandlerPath?: undefined;
 }
-interface TypeScriptDataSourceDefinition extends BaseDataSourceDefinition {
+interface TypeScriptServerLogicDefinition extends BaseServerLogicDefinition {
     _isTypescript: true;
     _tsHandlerPath: string;
     connectionId?: undefined;
     _query?: undefined;
 }
-type DataSourceDefinition = SqlDataSourceDefinition | TypeScriptDataSourceDefinition;
-interface BaseDataSourceMeta {
+type ServerLogicDefinition = SqlServerLogicDefinition | TypeScriptServerLogicDefinition;
+interface BaseServerLogicMeta {
     slug: string;
     description: string;
     parameters: ParameterMeta[];
-    response?: DataSourceResponse;
-    cache?: DataSourceCacheConfig;
+    response?: ServerLogicResponse;
+    cache?: ServerLogicCacheConfig;
 }
-interface SqlDataSourceMeta extends BaseDataSourceMeta {
+interface SqlServerLogicMeta extends BaseServerLogicMeta {
     type: "sql";
     connectionId: string;
     query: string;
     handlerPath?: undefined;
 }
-interface TypeScriptDataSourceMeta extends BaseDataSourceMeta {
+interface TypeScriptServerLogicMeta extends BaseServerLogicMeta {
     type: "typescript";
     handlerPath: string;
     connectionId?: undefined;
     query?: undefined;
 }
-type DataSourceMeta = SqlDataSourceMeta | TypeScriptDataSourceMeta;
-/** @deprecated Use JsonSqlDataSourceDefinition */
-type JsonDataSourceDefinition = JsonSqlDataSourceDefinition;
+type ServerLogicMeta = SqlServerLogicMeta | TypeScriptServerLogicMeta;
+/** @deprecated Use JsonSqlServerLogicDefinition */
+type JsonServerLogicDefinition = JsonSqlServerLogicDefinition;
 
-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 };
+export { type AnyJsonServerLogicDefinition, type JsonServerLogicDefinition, type JsonSqlServerLogicDefinition, type JsonTypeScriptServerLogicDefinition, type ParameterMeta, type ServerLogicCacheConfig, type ServerLogicDefinition, type ServerLogicMediaType, type ServerLogicMeta, type ServerLogicResponse, type ServerLogicSchemaObject, type SqlServerLogicDefinition, type SqlServerLogicMeta, type TypeScriptServerLogicDefinition, type TypeScriptServerLogicMeta, anyJsonServerLogicSchema, jsonSqlServerLogicSchema, jsonTypeScriptServerLogicSchema, parameterMetaSchema, serverLogicCacheConfigSchema, serverLogicMediaTypeSchema, serverLogicResponseSchema, serverLogicSchemaObjectSchema };

package/dist/types/{data-source.js → server-logic.js}

@@ -1,4 +1,4 @@
-// src/types/data-source.ts
+// src/types/server-logic.ts
 import { z } from "zod";
 var parameterMetaSchema = z.object({
   name: z.string(),
@@ -7,21 +7,21 @@ var parameterMetaSchema = z.object({
   required: z.boolean().optional(),
   default: z.union([z.string(), z.number(), z.boolean()]).optional()
 });
-var dataSourceCacheConfigSchema = z.object({
+var serverLogicCacheConfigSchema = z.object({
   ttl: z.number(),
   staleWhileRevalidate: z.boolean().optional()
 });
-var dataSourceSchemaObjectSchema = z.lazy(
+var serverLogicSchemaObjectSchema = 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(),
+    items: serverLogicSchemaObjectSchema.optional(),
+    properties: z.record(z.string(), serverLogicSchemaObjectSchema).optional(),
     required: z.array(z.string()).optional(),
-    additionalProperties: z.union([z.boolean(), dataSourceSchemaObjectSchema]).optional(),
+    additionalProperties: z.union([z.boolean(), serverLogicSchemaObjectSchema]).optional(),
     minimum: z.number().optional(),
     maximum: z.number().optional(),
     minLength: z.number().optional(),
@@ -29,42 +29,42 @@ var dataSourceSchemaObjectSchema = z.lazy(
     pattern: z.string().optional()
   })
 );
-var dataSourceMediaTypeSchema = z.object({
-  schema: dataSourceSchemaObjectSchema.optional(),
+var serverLogicMediaTypeSchema = z.object({
+  schema: serverLogicSchemaObjectSchema.optional(),
   example: z.unknown().optional()
 });
-var dataSourceResponseSchema = z.object({
+var serverLogicResponseSchema = z.object({
   description: z.string().optional(),
-  content: z.record(z.string(), dataSourceMediaTypeSchema).optional()
+  content: z.record(z.string(), serverLogicMediaTypeSchema).optional()
 });
 var jsonBaseFields = {
   description: z.string(),
   parameters: z.array(parameterMetaSchema).optional(),
-  response: dataSourceResponseSchema.optional(),
-  cache: dataSourceCacheConfigSchema.optional()
+  response: serverLogicResponseSchema.optional(),
+  cache: serverLogicCacheConfigSchema.optional()
 };
-var jsonSqlDataSourceSchema = z.object({
+var jsonSqlServerLogicSchema = z.object({
   ...jsonBaseFields,
   type: z.literal("sql").optional(),
   query: z.string(),
   connectionId: z.string()
 });
-var jsonTypeScriptDataSourceSchema = z.object({
+var jsonTypeScriptServerLogicSchema = z.object({
   ...jsonBaseFields,
   type: z.literal("typescript"),
   handlerPath: z.string()
 });
-var anyJsonDataSourceSchema = z.union([
-  jsonTypeScriptDataSourceSchema,
-  jsonSqlDataSourceSchema
+var anyJsonServerLogicSchema = z.union([
+  jsonTypeScriptServerLogicSchema,
+  jsonSqlServerLogicSchema
 ]);
 export {
-  anyJsonDataSourceSchema,
-  dataSourceCacheConfigSchema,
-  dataSourceMediaTypeSchema,
-  dataSourceResponseSchema,
-  dataSourceSchemaObjectSchema,
-  jsonSqlDataSourceSchema,
-  jsonTypeScriptDataSourceSchema,
-  parameterMetaSchema
+  anyJsonServerLogicSchema,
+  jsonSqlServerLogicSchema,
+  jsonTypeScriptServerLogicSchema,
+  parameterMetaSchema,
+  serverLogicCacheConfigSchema,
+  serverLogicMediaTypeSchema,
+  serverLogicResponseSchema,
+  serverLogicSchemaObjectSchema
 };

package/dist/vite-plugin.js

@@ -190,7 +190,7 @@ function resolveParams(entry, connectionId, plugin) {
 // src/connector-client/index.ts
 var { getQuery, loadConnections, reloadEnvFile, watchConnectionsFile } = createConnectorRegistry();
 
-// src/types/data-source.ts
+// src/types/server-logic.ts
 import { z } from "zod";
 var parameterMetaSchema = z.object({
   name: z.string(),
@@ -199,21 +199,21 @@ var parameterMetaSchema = z.object({
   required: z.boolean().optional(),
   default: z.union([z.string(), z.number(), z.boolean()]).optional()
 });
-var dataSourceCacheConfigSchema = z.object({
+var serverLogicCacheConfigSchema = z.object({
   ttl: z.number(),
   staleWhileRevalidate: z.boolean().optional()
 });
-var dataSourceSchemaObjectSchema = z.lazy(
+var serverLogicSchemaObjectSchema = 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(),
+    items: serverLogicSchemaObjectSchema.optional(),
+    properties: z.record(z.string(), serverLogicSchemaObjectSchema).optional(),
     required: z.array(z.string()).optional(),
-    additionalProperties: z.union([z.boolean(), dataSourceSchemaObjectSchema]).optional(),
+    additionalProperties: z.union([z.boolean(), serverLogicSchemaObjectSchema]).optional(),
     minimum: z.number().optional(),
     maximum: z.number().optional(),
     minLength: z.number().optional(),
@@ -221,34 +221,34 @@ var dataSourceSchemaObjectSchema = z.lazy(
     pattern: z.string().optional()
   })
 );
-var dataSourceMediaTypeSchema = z.object({
-  schema: dataSourceSchemaObjectSchema.optional(),
+var serverLogicMediaTypeSchema = z.object({
+  schema: serverLogicSchemaObjectSchema.optional(),
   example: z.unknown().optional()
 });
-var dataSourceResponseSchema = z.object({
+var serverLogicResponseSchema = z.object({
   description: z.string().optional(),
-  content: z.record(z.string(), dataSourceMediaTypeSchema).optional()
+  content: z.record(z.string(), serverLogicMediaTypeSchema).optional()
 });
 var jsonBaseFields = {
   description: z.string(),
   parameters: z.array(parameterMetaSchema).optional(),
-  response: dataSourceResponseSchema.optional(),
-  cache: dataSourceCacheConfigSchema.optional()
+  response: serverLogicResponseSchema.optional(),
+  cache: serverLogicCacheConfigSchema.optional()
 };
-var jsonSqlDataSourceSchema = z.object({
+var jsonSqlServerLogicSchema = z.object({
   ...jsonBaseFields,
   type: z.literal("sql").optional(),
   query: z.string(),
   connectionId: z.string()
 });
-var jsonTypeScriptDataSourceSchema = z.object({
+var jsonTypeScriptServerLogicSchema = z.object({
   ...jsonBaseFields,
   type: z.literal("typescript"),
   handlerPath: z.string()
 });
-var anyJsonDataSourceSchema = z.union([
-  jsonTypeScriptDataSourceSchema,
-  jsonSqlDataSourceSchema
+var anyJsonServerLogicSchema = z.union([
+  jsonTypeScriptServerLogicSchema,
+  jsonSqlServerLogicSchema
 ]);
 
 // src/registry.ts
@@ -256,7 +256,7 @@ var viteServer = null;
 function setViteServer(server) {
   viteServer = server;
 }
-var defaultDataSourceDir = path2.join(process.cwd(), "data-source");
+var defaultServerLogicDir = path2.join(process.cwd(), "server-logic");
 
 // src/vite-plugin.ts
 var DEFAULT_EXCLUDE = [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@squadbase/vite-server",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "type": "module",
   "exports": {
     ".": {
@@ -12,8 +12,8 @@
       "types": "./dist/main.d.ts"
     },
     "./types": {
-      "import": "./dist/types/data-source.js",
-      "types": "./dist/types/data-source.d.ts"
+      "import": "./dist/types/server-logic.js",
+      "types": "./dist/types/server-logic.d.ts"
     },
     "./plugin": {
       "import": "./dist/vite-plugin.js",
@@ -35,7 +35,7 @@
     "access": "public"
   },
   "bin": {
-    "squadbase-ds-test": "./dist/cli/index.js"
+    "squadbase-sl-test": "./dist/cli/index.js"
   },
   "scripts": {
     "cli": "tsx src/cli/index.ts",
@@ -45,7 +45,7 @@
     "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 mysql2 --external @aws-sdk/client-athena --external @aws-sdk/client-redshift-data --external @databricks/sql --external @google-analytics/data --external @kintone/rest-api-client --external hono --external @clack/prompts"
   },
   "dependencies": {
-    "@squadbase/connectors": "^0.0.14",
+    "@squadbase/connectors": "^0.0.16",
     "@aws-sdk/client-athena": "^3.750.0",
     "@aws-sdk/client-redshift-data": "^3.750.0",
     "@databricks/sql": "^1.8.0",