over-zero 0.0.32 → 0.0.34

package/cli.cjs

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+// needs to be here before build so it links in
+require('./dist/cjs/cli.cjs')

package/dist/cjs/cli.cjs

@@ -21,11 +21,11 @@ isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
   value: mod,
   enumerable: !0
 }) : target, mod));
-var import_model = require("@sinclair/typebox-codegen/model"),
+var import_node_fs = require("node:fs"),
+  import_node_path = require("node:path"),
+  import_model = require("@sinclair/typebox-codegen/model"),
   import_typescript = require("@sinclair/typebox-codegen/typescript"),
   import_citty = require("citty"),
-  import_node_fs = require("node:fs"),
-  import_node_path = require("node:path"),
   ts = __toESM(require("typescript"), 1);
 function writeFileIfChanged(filePath, content) {
   try {
@@ -34,184 +34,187 @@ function writeFileIfChanged(filePath, content) {
   return (0, import_node_fs.writeFileSync)(filePath, content, "utf-8"), !0;
 }
 const generateQueries = (0, import_citty.defineCommand)({
-  meta: {
-    name: "generate-queries",
-    description: "Generate server-side query validators from TypeScript query functions"
-  },
-  args: {
-    dir: {
-      type: "positional",
-      description: "Directory containing query files",
-      required: !1,
-      default: "."
-    }
-  },
-  async run({
-    args
-  }) {
-    const dir = (0, import_node_path.resolve)(args.dir),
-      {
-        readdirSync: readdirSync2,
-        writeFileSync: writeFileSync2
-      } = await import("node:fs"),
-      files = readdirSync2(dir).filter(f => f.endsWith(".ts")),
-      allQueries = [],
-      results = await Promise.all(files.map(async file => {
-        const filePath = (0, import_node_path.resolve)(dir, file),
-          queries = [];
-        try {
-          const content = (0, import_node_fs.readFileSync)(filePath, "utf-8"),
-            sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, !0);
-          ts.forEachChild(sourceFile, node => {
-            if (ts.isVariableStatement(node)) {
-              if (!node.modifiers?.find(m => m.kind === ts.SyntaxKind.ExportKeyword)) return;
-              const declaration = node.declarationList.declarations[0];
-              if (!declaration || !ts.isVariableDeclaration(declaration)) return;
-              const name = declaration.name.getText(sourceFile);
-              if (declaration.initializer && ts.isArrowFunction(declaration.initializer)) {
-                const params = declaration.initializer.parameters;
-                let paramType = "void";
-                params.length > 0 && (paramType = params[0].type?.getText(sourceFile) || "unknown");
-                try {
-                  const typeString = `type QueryParams = ${paramType}`,
-                    model = import_typescript.TypeScriptToModel.Generate(typeString),
-                    valibotCode = import_model.ModelToValibot.Generate(model);
-                  queries.push({
-                    name,
-                    params: paramType,
-                    valibotCode
-                  });
-                } catch (err) {
-                  console.error(`\u2717 ${name}: ${err}`);
+    meta: {
+      name: "generate-queries",
+      description: "Generate server-side query validators from TypeScript query functions"
+    },
+    args: {
+      dir: {
+        type: "positional",
+        description: "Directory containing query files",
+        required: !1,
+        default: "."
+      }
+    },
+    async run({
+      args
+    }) {
+      const dir = (0, import_node_path.resolve)(args.dir),
+        {
+          readdirSync: readdirSync2,
+          writeFileSync: writeFileSync2
+        } = await import("node:fs"),
+        files = readdirSync2(dir).filter(f => f.endsWith(".ts")),
+        allQueries = [],
+        results = await Promise.all(files.map(async file => {
+          const filePath = (0, import_node_path.resolve)(dir, file),
+            queries = [];
+          try {
+            const content = (0, import_node_fs.readFileSync)(filePath, "utf-8"),
+              sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, !0);
+            ts.forEachChild(sourceFile, node => {
+              if (ts.isVariableStatement(node)) {
+                if (!node.modifiers?.find(m => m.kind === ts.SyntaxKind.ExportKeyword)) return;
+                const declaration = node.declarationList.declarations[0];
+                if (!declaration || !ts.isVariableDeclaration(declaration)) return;
+                const name = declaration.name.getText(sourceFile);
+                if (declaration.initializer && ts.isArrowFunction(declaration.initializer)) {
+                  const params = declaration.initializer.parameters;
+                  let paramType = "void";
+                  params.length > 0 && (paramType = params[0].type?.getText(sourceFile) || "unknown");
+                  try {
+                    const typeString = `type QueryParams = ${paramType}`,
+                      model = import_typescript.TypeScriptToModel.Generate(typeString),
+                      valibotCode = import_model.ModelToValibot.Generate(model);
+                    queries.push({
+                      name,
+                      params: paramType,
+                      valibotCode
+                    });
+                  } catch (err) {
+                    console.error(`\u2717 ${name}: ${err}`);
+                  }
                 }
               }
-            }
-          });
-        } catch (err) {
-          console.error(`Error processing ${file}:`, err);
-        }
-        return queries;
-      }));
-    allQueries.push(...results.flat()), console.info(`\u2713 ${allQueries.length} query validators`);
-  }
-});
-const generate = (0, import_citty.defineCommand)({
-  meta: {
-    name: "generate",
-    description: "Generate models, types, tables, and query validators"
-  },
-  args: {
-    dir: {
-      type: "positional",
-      description: "Base directory (defaults to src/data)",
-      required: !1,
-      default: "src/data"
+            });
+          } catch (err) {
+            console.error(`Error processing ${file}:`, err);
+          }
+          return queries;
+        }));
+      allQueries.push(...results.flat()), console.info(`\u2713 ${allQueries.length} query validators`);
+    }
+  }),
+  generate = (0, import_citty.defineCommand)({
+    meta: {
+      name: "generate",
+      description: "Generate models, types, tables, and query validators"
     },
-    watch: {
-      type: "boolean",
-      description: "Watch for changes and regenerate",
-      required: !1,
-      default: !1
+    args: {
+      dir: {
+        type: "positional",
+        description: "Base directory (defaults to src/data)",
+        required: !1,
+        default: "src/data"
+      },
+      watch: {
+        type: "boolean",
+        description: "Watch for changes and regenerate",
+        required: !1,
+        default: !1
+      },
+      after: {
+        type: "string",
+        description: "Command to run after generation completes",
+        required: !1
+      }
     },
-    after: {
-      type: "string",
-      description: "Command to run after generation completes",
-      required: !1
-    }
-  },
-  async run({
-    args
-  }) {
-    const baseDir = (0, import_node_path.resolve)(args.dir),
-      modelsDir = (0, import_node_path.resolve)(baseDir, "models"),
-      generatedDir = (0, import_node_path.resolve)(baseDir, "generated"),
-      queriesDir = (0, import_node_path.resolve)(baseDir, "queries"),
-      runGenerate = async () => {
-        (0, import_node_fs.existsSync)(generatedDir) || (0, import_node_fs.mkdirSync)(generatedDir, {
-          recursive: !0
-        });
-        const allModelFiles = (0, import_node_fs.readdirSync)(modelsDir).filter(f => f.endsWith(".ts")).sort(),
-          filesWithSchema = (await Promise.all(allModelFiles.map(async f => ({
-            file: f,
-            hasSchema: (0, import_node_fs.readFileSync)((0, import_node_path.resolve)(modelsDir, f), "utf-8").includes("export const schema = table(")
-          })))).filter(c => c.hasSchema).map(c => c.file),
-          [modelsOutput, typesOutput, tablesOutput, readmeOutput] = await Promise.all([Promise.resolve(generateModelsFile(allModelFiles)), Promise.resolve(generateTypesFile(filesWithSchema)), Promise.resolve(generateTablesFile(filesWithSchema)), Promise.resolve(generateReadmeFile())]),
-          filesChanged = (await Promise.all([Promise.resolve(writeFileIfChanged((0, import_node_path.resolve)(generatedDir, "models.ts"), modelsOutput)), Promise.resolve(writeFileIfChanged((0, import_node_path.resolve)(generatedDir, "types.ts"), typesOutput)), Promise.resolve(writeFileIfChanged((0, import_node_path.resolve)(generatedDir, "tables.ts"), tablesOutput)), Promise.resolve(writeFileIfChanged((0, import_node_path.resolve)(generatedDir, "README.md"), readmeOutput))])).filter(Boolean).length;
-        if (filesChanged > 0 && console.info(`  \u{1F4DD} Updated ${filesChanged} file(s)`), (0, import_node_fs.existsSync)(queriesDir)) {
-          const queryFiles = (0, import_node_fs.readdirSync)(queriesDir).filter(f => f.endsWith(".ts")),
-            allQueries = (await Promise.all(queryFiles.map(async file => {
-              const filePath = (0, import_node_path.resolve)(queriesDir, file),
-                fileBaseName = (0, import_node_path.basename)(file, ".ts"),
-                queries = [];
-              try {
-                const content = (0, import_node_fs.readFileSync)(filePath, "utf-8"),
-                  sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, !0);
-                ts.forEachChild(sourceFile, node => {
-                  if (ts.isVariableStatement(node)) {
-                    if (!node.modifiers?.find(m => m.kind === ts.SyntaxKind.ExportKeyword)) return;
-                    const declaration = node.declarationList.declarations[0];
-                    if (!declaration || !ts.isVariableDeclaration(declaration)) return;
-                    const name = declaration.name.getText(sourceFile);
-                    if (name === "permission") return;
-                    if (declaration.initializer && ts.isArrowFunction(declaration.initializer)) {
-                      const params = declaration.initializer.parameters;
-                      let paramType = "void";
-                      params.length > 0 && (paramType = params[0].type?.getText(sourceFile) || "unknown");
-                      try {
-                        const typeString = `type QueryParams = ${paramType}`,
-                          model = import_typescript.TypeScriptToModel.Generate(typeString),
-                          valibotCode = import_model.ModelToValibot.Generate(model);
-                        queries.push({
-                          name,
-                          params: paramType,
-                          valibotCode,
-                          sourceFile: fileBaseName
-                        });
-                      } catch (err) {
-                        console.error(`\u2717 ${name}: ${err}`);
+    async run({
+      args
+    }) {
+      const baseDir = (0, import_node_path.resolve)(args.dir),
+        modelsDir = (0, import_node_path.resolve)(baseDir, "models"),
+        generatedDir = (0, import_node_path.resolve)(baseDir, "generated"),
+        queriesDir = (0, import_node_path.resolve)(baseDir, "queries"),
+        runGenerate = async () => {
+          (0, import_node_fs.existsSync)(generatedDir) || (0, import_node_fs.mkdirSync)(generatedDir, {
+            recursive: !0
+          });
+          const allModelFiles = (0, import_node_fs.readdirSync)(modelsDir).filter(f => f.endsWith(".ts")).sort(),
+            filesWithSchema = (await Promise.all(allModelFiles.map(async f => ({
+              file: f,
+              hasSchema: (0, import_node_fs.readFileSync)((0, import_node_path.resolve)(modelsDir, f), "utf-8").includes("export const schema = table(")
+            })))).filter(c => c.hasSchema).map(c => c.file),
+            [modelsOutput, typesOutput, tablesOutput, readmeOutput] = await Promise.all([Promise.resolve(generateModelsFile(allModelFiles)), Promise.resolve(generateTypesFile(filesWithSchema)), Promise.resolve(generateTablesFile(filesWithSchema)), Promise.resolve(generateReadmeFile())]),
+            filesChanged = (await Promise.all([Promise.resolve(writeFileIfChanged((0, import_node_path.resolve)(generatedDir, "models.ts"), modelsOutput)), Promise.resolve(writeFileIfChanged((0, import_node_path.resolve)(generatedDir, "types.ts"), typesOutput)), Promise.resolve(writeFileIfChanged((0, import_node_path.resolve)(generatedDir, "tables.ts"), tablesOutput)), Promise.resolve(writeFileIfChanged((0, import_node_path.resolve)(generatedDir, "README.md"), readmeOutput))])).filter(Boolean).length;
+          if (filesChanged > 0 && console.info(`  \u{1F4DD} Updated ${filesChanged} file(s)`), (0, import_node_fs.existsSync)(queriesDir)) {
+            const queryFiles = (0, import_node_fs.readdirSync)(queriesDir).filter(f => f.endsWith(".ts")),
+              allQueries = (await Promise.all(queryFiles.map(async file => {
+                const filePath = (0, import_node_path.resolve)(queriesDir, file),
+                  fileBaseName = (0, import_node_path.basename)(file, ".ts"),
+                  queries = [];
+                try {
+                  const content = (0, import_node_fs.readFileSync)(filePath, "utf-8"),
+                    sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, !0);
+                  ts.forEachChild(sourceFile, node => {
+                    if (ts.isVariableStatement(node)) {
+                      if (!node.modifiers?.find(m => m.kind === ts.SyntaxKind.ExportKeyword)) return;
+                      const declaration = node.declarationList.declarations[0];
+                      if (!declaration || !ts.isVariableDeclaration(declaration)) return;
+                      const name = declaration.name.getText(sourceFile);
+                      if (name === "permission") return;
+                      if (declaration.initializer && ts.isArrowFunction(declaration.initializer)) {
+                        const params = declaration.initializer.parameters;
+                        let paramType = "void";
+                        params.length > 0 && (paramType = params[0].type?.getText(sourceFile) || "unknown");
+                        try {
+                          const typeString = `type QueryParams = ${paramType}`,
+                            model = import_typescript.TypeScriptToModel.Generate(typeString),
+                            valibotCode = import_model.ModelToValibot.Generate(model);
+                          queries.push({
+                            name,
+                            params: paramType,
+                            valibotCode,
+                            sourceFile: fileBaseName
+                          });
+                        } catch (err) {
+                          console.error(`\u2717 ${name}: ${err}`);
+                        }
                       }
                     }
-                  }
-                });
-              } catch (err) {
-                console.error(`Error processing ${file}:`, err);
-              }
-              return queries;
-            }))).flat(),
-            queriesOutput = generateQueriesFile(allQueries);
-          writeFileIfChanged((0, import_node_path.resolve)(generatedDir, "queries.ts"), queriesOutput) && console.info("  \u{1F4DD} Updated queries.ts"), console.info(`\u2713 ${allModelFiles.length} models (${filesWithSchema.length} schemas), ${allQueries.length} queries`);
-        } else console.info(`\u2713 ${allModelFiles.length} models (${filesWithSchema.length} schemas)`);
-        if (args.after) try {
-          const {
-            execSync
-          } = await import("node:child_process");
-          execSync(args.after, {
-            stdio: "inherit"
-          });
-        } catch (err) {
-          console.error(`Error running after command: ${err}`);
-        }
-      };
-    if (await runGenerate(), args.watch) {
-      console.info(`
+                  });
+                } catch (err) {
+                  console.error(`Error processing ${file}:`, err);
+                }
+                return queries;
+              }))).flat(),
+              groupedQueriesOutput = generateGroupedQueriesFile(allQueries),
+              syncedQueriesOutput = generateSyncedQueriesFile(allQueries),
+              groupedChanged = writeFileIfChanged((0, import_node_path.resolve)(generatedDir, "groupedQueries.ts"), groupedQueriesOutput),
+              syncedChanged = writeFileIfChanged((0, import_node_path.resolve)(generatedDir, "syncedQueries.ts"), syncedQueriesOutput);
+            groupedChanged && console.info("  \u{1F4DD} Updated groupedQueries.ts"), syncedChanged && console.info("  \u{1F4DD} Updated syncedQueries.ts"), console.info(`\u2713 ${allModelFiles.length} models (${filesWithSchema.length} schemas), ${allQueries.length} queries`);
+          } else console.info(`\u2713 ${allModelFiles.length} models (${filesWithSchema.length} schemas)`);
+          if (args.after) try {
+            const {
+              execSync
+            } = await import("node:child_process");
+            execSync(args.after, {
+              stdio: "inherit"
+            });
+          } catch (err) {
+            console.error(`Error running after command: ${err}`);
+          }
+        };
+      if (await runGenerate(), args.watch) {
+        console.info(`
 \u{1F440} watching...
 `);
-      const chokidar = await import("chokidar");
-      let debounceTimer = null;
-      const debouncedRegenerate = (path, event) => {
-          debounceTimer && clearTimeout(debounceTimer), console.info(`
+        const chokidar = await import("chokidar");
+        let debounceTimer = null;
+        const debouncedRegenerate = (path, event) => {
+            debounceTimer && clearTimeout(debounceTimer), console.info(`
 ${event} ${path}`), debounceTimer = setTimeout(() => {
-            runGenerate();
-          }, 1e3);
-        },
-        watcher = chokidar.watch([modelsDir, queriesDir], {
-          persistent: !0,
-          ignoreInitial: !0
-        });
-      watcher.on("change", path => debouncedRegenerate(path, "\u{1F4DD}")), watcher.on("add", path => debouncedRegenerate(path, "\u2795")), watcher.on("unlink", path => debouncedRegenerate(path, "\u{1F5D1}\uFE0F ")), await new Promise(() => {});
+              runGenerate();
+            }, 1e3);
+          },
+          watcher = chokidar.watch([modelsDir, queriesDir], {
+            persistent: !0,
+            ignoreInitial: !0
+          });
+        watcher.on("change", path => debouncedRegenerate(path, "\u{1F4DD}")), watcher.on("add", path => debouncedRegenerate(path, "\u2795")), watcher.on("unlink", path => debouncedRegenerate(path, "\u{1F5D1}\uFE0F ")), await new Promise(() => {});
+      }
     }
-  }
-});
+  });
 function generateModelsFile(modelFiles) {
   const modelNames = modelFiles.map(f => (0, import_node_path.basename)(f, ".ts")).sort(),
     getImportName = name => name === "user" ? "userPublic" : name,
@@ -253,44 +256,60 @@ ${modelNames.map(name => `export { schema as ${getExportName(name)} } from '../m
 `)}
 `;
 }
-function generateQueriesFile(queries) {
-  const sortedQueries = [...queries].sort((a, b) => a.name.localeCompare(b.name)),
-    queryByFile = /* @__PURE__ */new Map();
-  for (const q of sortedQueries) queryByFile.has(q.sourceFile) || queryByFile.set(q.sourceFile, []), queryByFile.get(q.sourceFile).push(q);
-  const imports = `import * as v from 'valibot'
-import { syncedQuery } from '@rocicorp/zero'
-${Array.from(queryByFile.keys()).sort().map(file => `import * as ${file}Queries from '../queries/${file}'`).join(`
+function generateGroupedQueriesFile(queries) {
+  return `/**
+ * auto-generated by: over-zero generate
+ *
+ * grouped query re-exports for minification-safe query identity.
+ * this file re-exports all query modules - while this breaks tree-shaking,
+ * queries are typically small and few in number even in larger apps.
+ */
+${[...new Set(queries.map(q => q.sourceFile))].sort().map(file => `export * as ${file} from '../queries/${file}'`).join(`
 `)}
+`;
+}
+function generateSyncedQueriesFile(queries) {
+  const queryByFile = /* @__PURE__ */new Map();
+  for (const q of queries) queryByFile.has(q.sourceFile) || queryByFile.set(q.sourceFile, []), queryByFile.get(q.sourceFile).push(q);
+  const sortedFiles = Array.from(queryByFile.keys()).sort(),
+    imports = `// auto-generated by: over-zero generate
+// server-side syncedQuery wrappers with validators
+import { syncedQuery } from '@rocicorp/zero'
+import * as v from 'valibot'
+import * as Queries from './groupedQueries'
 `,
-    syncedQueries = sortedQueries.map(q => {
-      const lines = q.valibotCode.split(`
+    namespaceExports = sortedFiles.map(file => {
+      const queryDefs = queryByFile.get(file).sort((a, b) => a.name.localeCompare(b.name)).map(q => {
+        const lines = q.valibotCode.split(`
 `).filter(l => l.trim()),
-        schemaLineIndex = lines.findIndex(l => l.startsWith("export const QueryParams"));
-      let validatorDef = "v.void()";
-      if (schemaLineIndex !== -1) {
-        const schemaLines = [];
-        let openBraces = 0,
-          started = !1;
-        for (let i = schemaLineIndex; i < lines.length; i++) {
-          const line = lines[i],
-            cleaned = started ? line : line.replace("export const QueryParams = ", "");
-          if (schemaLines.push(cleaned), started = !0, openBraces += (cleaned.match(/\{/g) || []).length, openBraces -= (cleaned.match(/\}/g) || []).length, openBraces += (cleaned.match(/\(/g) || []).length, openBraces -= (cleaned.match(/\)/g) || []).length, openBraces === 0 && schemaLines.length > 0) break;
+          schemaLineIndex = lines.findIndex(l => l.startsWith("export const QueryParams"));
+        let validatorDef = "v.void()";
+        if (schemaLineIndex !== -1) {
+          const schemaLines = [];
+          let openBraces = 0,
+            started = !1;
+          for (let i = schemaLineIndex; i < lines.length; i++) {
+            const line = lines[i],
+              cleaned = started ? line : line.replace("export const QueryParams = ", "");
+            if (schemaLines.push(cleaned), started = !0, openBraces += (cleaned.match(/\{/g) || []).length, openBraces -= (cleaned.match(/\}/g) || []).length, openBraces += (cleaned.match(/\(/g) || []).length, openBraces -= (cleaned.match(/\)/g) || []).length, openBraces === 0 && schemaLines.length > 0) break;
+          }
+          validatorDef = schemaLines.join(`
+`);
         }
-        validatorDef = schemaLines.join(`
+        const wrappedValidator = validatorDef === "v.void()" ? "v.parser(v.tuple([]))" : `v.parser(v.tuple([${validatorDef}]))`,
+          namespacedName = `${q.sourceFile}.${q.name}`,
+          queryFn = validatorDef === "v.void()" ? `() => Queries.${file}.${q.name}()` : `(arg) => Queries.${file}.${q.name}(arg)`;
+        return `  ${q.name}: syncedQuery('${namespacedName}', ${wrappedValidator}, ${queryFn}),`;
+      }).join(`
 `);
-      }
-      const wrappedValidator = validatorDef === "v.void()" ? "v.parser(v.tuple([]))" : `v.parser(v.tuple([${validatorDef}]))`,
-        queryFn = validatorDef === "v.void()" ? `() => {
-  return ${q.sourceFile}Queries.${q.name}()
-}` : `(arg) => {
-  return ${q.sourceFile}Queries.${q.name}(arg)
+      return `export const ${file} = {
+${queryDefs}
 }`;
-      return `export const ${q.name} = syncedQuery('${q.name}', ${wrappedValidator}, ${queryFn})`;
     }).join(`
 
 `);
-  return imports + `
-` + syncedQueries + `
+  return `${imports}
+${namespaceExports}
 `;
 }
 function generateReadmeFile() {
@@ -303,7 +322,8 @@ this folder is auto-generated by over-zero. do not edit files here directly.
 - \`models.ts\` - exports all models from ../models
 - \`types.ts\` - typescript types derived from table schemas
 - \`tables.ts\` - exports table schemas for type inference
-- \`queries.ts\` - synced query definitions with validators
+- \`groupedQueries.ts\` - namespaced query re-exports for client setup
+- \`syncedQueries.ts\` - namespaced syncedQuery wrappers for server setup
 
 ## usage guidelines
 
@@ -311,16 +331,15 @@ this folder is auto-generated by over-zero. do not edit files here directly.
 
 ### queries
 
-don't import queries from this folder on the client. instead, import from \`../queries/\`:
+write your queries as plain functions in \`../queries/\` and import them directly:
 
 \`\`\`ts
-// \u274C bad - don't import from generated
-import { channelMessages } from '~/data/generated/queries'
-
 // \u2705 good - import from queries
 import { channelMessages } from '~/data/queries/message'
 \`\`\`
 
+the generated query files are only used internally by zero client/server setup.
+
 ### types
 
 you can import types from this folder, but prefer re-exporting from \`../types.ts\`: