over-zero 0.0.32 → 0.0.33

package/dist/esm/cli.native.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "fs";
+import { basename, resolve } from "path";
 import { ModelToValibot } from "@sinclair/typebox-codegen/model";
 import { TypeScriptToModel } from "@sinclair/typebox-codegen/typescript";
 import { defineCommand, runMain } from "citty";
-import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "fs";
-import { basename, resolve } from "path";
 import * as ts from "typescript";
 function writeFileIfChanged(filePath, content) {
   try {
@@ -15,224 +15,226 @@ function writeFileIfChanged(filePath, content) {
   return writeFileSync(filePath, content, "utf-8"), !0;
 }
 var generateQueries = 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(param) {
-    var {
-        args
-      } = param,
-      dir = resolve(args.dir),
-      {
-        readdirSync: readdirSync2,
-        writeFileSync: writeFileSync2
-      } = await import("fs"),
-      files = readdirSync2(dir).filter(function (f) {
-        return f.endsWith(".ts");
-      }),
-      allQueries = [],
-      results = await Promise.all(files.map(async function (file) {
-        var filePath = resolve(dir, file),
-          queries = [];
-        try {
-          var content = readFileSync(filePath, "utf-8"),
-            sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, !0);
-          ts.forEachChild(sourceFile, function (node) {
-            if (ts.isVariableStatement(node)) {
-              var _node_modifiers,
-                exportModifier = (_node_modifiers = node.modifiers) === null || _node_modifiers === void 0 ? void 0 : _node_modifiers.find(function (m) {
-                  return m.kind === ts.SyntaxKind.ExportKeyword;
-                });
-              if (!exportModifier) return;
-              var declaration = node.declarationList.declarations[0];
-              if (!declaration || !ts.isVariableDeclaration(declaration)) return;
-              var name = declaration.name.getText(sourceFile);
-              if (declaration.initializer && ts.isArrowFunction(declaration.initializer)) {
-                var params = declaration.initializer.parameters,
-                  paramType = "void";
-                if (params.length > 0) {
-                  var _param_type,
-                    _$param = params[0];
-                  paramType = ((_param_type = _$param.type) === null || _param_type === void 0 ? void 0 : _param_type.getText(sourceFile)) || "unknown";
-                }
-                try {
-                  var typeString = `type QueryParams = ${paramType}`,
-                    model = TypeScriptToModel.Generate(typeString),
-                    valibotCode = ModelToValibot.Generate(model);
-                  queries.push({
-                    name,
-                    params: paramType,
-                    valibotCode
+    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(param) {
+      var {
+          args
+        } = param,
+        dir = resolve(args.dir),
+        {
+          readdirSync: readdirSync2,
+          writeFileSync: writeFileSync2
+        } = await import("fs"),
+        files = readdirSync2(dir).filter(function (f) {
+          return f.endsWith(".ts");
+        }),
+        allQueries = [],
+        results = await Promise.all(files.map(async function (file) {
+          var filePath = resolve(dir, file),
+            queries = [];
+          try {
+            var content = readFileSync(filePath, "utf-8"),
+              sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, !0);
+            ts.forEachChild(sourceFile, function (node) {
+              if (ts.isVariableStatement(node)) {
+                var _node_modifiers,
+                  exportModifier = (_node_modifiers = node.modifiers) === null || _node_modifiers === void 0 ? void 0 : _node_modifiers.find(function (m) {
+                    return m.kind === ts.SyntaxKind.ExportKeyword;
                   });
-                } catch (err) {
-                  console.error(`\u2717 ${name}: ${err}`);
+                if (!exportModifier) return;
+                var declaration = node.declarationList.declarations[0];
+                if (!declaration || !ts.isVariableDeclaration(declaration)) return;
+                var name = declaration.name.getText(sourceFile);
+                if (declaration.initializer && ts.isArrowFunction(declaration.initializer)) {
+                  var params = declaration.initializer.parameters,
+                    paramType = "void";
+                  if (params.length > 0) {
+                    var _param_type,
+                      _$param = params[0];
+                    paramType = ((_param_type = _$param.type) === null || _param_type === void 0 ? void 0 : _param_type.getText(sourceFile)) || "unknown";
+                  }
+                  try {
+                    var typeString = `type QueryParams = ${paramType}`,
+                      model = TypeScriptToModel.Generate(typeString),
+                      valibotCode = 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`);
-  }
-});
-var generate = 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 = 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(param) {
-    var {
-        args
-      } = param,
-      baseDir = resolve(args.dir),
-      modelsDir = resolve(baseDir, "models"),
-      generatedDir = resolve(baseDir, "generated"),
-      queriesDir = resolve(baseDir, "queries"),
-      runGenerate = async function () {
-        existsSync(generatedDir) || mkdirSync(generatedDir, {
-          recursive: !0
-        });
-        var allModelFiles = readdirSync(modelsDir).filter(function (f) {
-            return f.endsWith(".ts");
-          }).sort(),
-          schemaChecks = await Promise.all(allModelFiles.map(async function (f) {
-            return {
-              file: f,
-              hasSchema: readFileSync(resolve(modelsDir, f), "utf-8").includes("export const schema = table(")
-            };
-          })),
-          filesWithSchema = schemaChecks.filter(function (c) {
-            return c.hasSchema;
-          }).map(function (c) {
-            return c.file;
-          }),
-          [modelsOutput, typesOutput, tablesOutput, readmeOutput] = await Promise.all([Promise.resolve(generateModelsFile(allModelFiles)), Promise.resolve(generateTypesFile(filesWithSchema)), Promise.resolve(generateTablesFile(filesWithSchema)), Promise.resolve(generateReadmeFile())]),
-          writeResults = await Promise.all([Promise.resolve(writeFileIfChanged(resolve(generatedDir, "models.ts"), modelsOutput)), Promise.resolve(writeFileIfChanged(resolve(generatedDir, "types.ts"), typesOutput)), Promise.resolve(writeFileIfChanged(resolve(generatedDir, "tables.ts"), tablesOutput)), Promise.resolve(writeFileIfChanged(resolve(generatedDir, "README.md"), readmeOutput))]),
-          filesChanged = writeResults.filter(Boolean).length;
-        if (filesChanged > 0 && console.info(`  \u{1F4DD} Updated ${filesChanged} file(s)`), existsSync(queriesDir)) {
-          var queryFiles = readdirSync(queriesDir).filter(function (f) {
+    async run(param) {
+      var {
+          args
+        } = param,
+        baseDir = resolve(args.dir),
+        modelsDir = resolve(baseDir, "models"),
+        generatedDir = resolve(baseDir, "generated"),
+        queriesDir = resolve(baseDir, "queries"),
+        runGenerate = async function () {
+          existsSync(generatedDir) || mkdirSync(generatedDir, {
+            recursive: !0
+          });
+          var allModelFiles = readdirSync(modelsDir).filter(function (f) {
               return f.endsWith(".ts");
+            }).sort(),
+            schemaChecks = await Promise.all(allModelFiles.map(async function (f) {
+              return {
+                file: f,
+                hasSchema: readFileSync(resolve(modelsDir, f), "utf-8").includes("export const schema = table(")
+              };
+            })),
+            filesWithSchema = schemaChecks.filter(function (c) {
+              return c.hasSchema;
+            }).map(function (c) {
+              return c.file;
             }),
-            queryResults = await Promise.all(queryFiles.map(async function (file) {
-              var filePath = resolve(queriesDir, file),
-                fileBaseName = basename(file, ".ts"),
-                queries = [];
-              try {
-                var content = readFileSync(filePath, "utf-8"),
-                  sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, !0);
-                ts.forEachChild(sourceFile, function (node) {
-                  if (ts.isVariableStatement(node)) {
-                    var _node_modifiers,
-                      exportModifier = (_node_modifiers = node.modifiers) === null || _node_modifiers === void 0 ? void 0 : _node_modifiers.find(function (m) {
-                        return m.kind === ts.SyntaxKind.ExportKeyword;
-                      });
-                    if (!exportModifier) return;
-                    var declaration = node.declarationList.declarations[0];
-                    if (!declaration || !ts.isVariableDeclaration(declaration)) return;
-                    var name = declaration.name.getText(sourceFile);
-                    if (name === "permission") return;
-                    if (declaration.initializer && ts.isArrowFunction(declaration.initializer)) {
-                      var params = declaration.initializer.parameters,
-                        paramType = "void";
-                      if (params.length > 0) {
-                        var _param_type,
-                          _$param = params[0];
-                        paramType = ((_param_type = _$param.type) === null || _param_type === void 0 ? void 0 : _param_type.getText(sourceFile)) || "unknown";
-                      }
-                      try {
-                        var typeString = `type QueryParams = ${paramType}`,
-                          model = TypeScriptToModel.Generate(typeString),
-                          valibotCode = ModelToValibot.Generate(model);
-                        queries.push({
-                          name,
-                          params: paramType,
-                          valibotCode,
-                          sourceFile: fileBaseName
+            [modelsOutput, typesOutput, tablesOutput, readmeOutput] = await Promise.all([Promise.resolve(generateModelsFile(allModelFiles)), Promise.resolve(generateTypesFile(filesWithSchema)), Promise.resolve(generateTablesFile(filesWithSchema)), Promise.resolve(generateReadmeFile())]),
+            writeResults = await Promise.all([Promise.resolve(writeFileIfChanged(resolve(generatedDir, "models.ts"), modelsOutput)), Promise.resolve(writeFileIfChanged(resolve(generatedDir, "types.ts"), typesOutput)), Promise.resolve(writeFileIfChanged(resolve(generatedDir, "tables.ts"), tablesOutput)), Promise.resolve(writeFileIfChanged(resolve(generatedDir, "README.md"), readmeOutput))]),
+            filesChanged = writeResults.filter(Boolean).length;
+          if (filesChanged > 0 && console.info(`  \u{1F4DD} Updated ${filesChanged} file(s)`), existsSync(queriesDir)) {
+            var queryFiles = readdirSync(queriesDir).filter(function (f) {
+                return f.endsWith(".ts");
+              }),
+              queryResults = await Promise.all(queryFiles.map(async function (file) {
+                var filePath = resolve(queriesDir, file),
+                  fileBaseName = basename(file, ".ts"),
+                  queries = [];
+                try {
+                  var content = readFileSync(filePath, "utf-8"),
+                    sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, !0);
+                  ts.forEachChild(sourceFile, function (node) {
+                    if (ts.isVariableStatement(node)) {
+                      var _node_modifiers,
+                        exportModifier = (_node_modifiers = node.modifiers) === null || _node_modifiers === void 0 ? void 0 : _node_modifiers.find(function (m) {
+                          return m.kind === ts.SyntaxKind.ExportKeyword;
                         });
-                      } catch (err) {
-                        console.error(`\u2717 ${name}: ${err}`);
+                      if (!exportModifier) return;
+                      var declaration = node.declarationList.declarations[0];
+                      if (!declaration || !ts.isVariableDeclaration(declaration)) return;
+                      var name = declaration.name.getText(sourceFile);
+                      if (name === "permission") return;
+                      if (declaration.initializer && ts.isArrowFunction(declaration.initializer)) {
+                        var params = declaration.initializer.parameters,
+                          paramType = "void";
+                        if (params.length > 0) {
+                          var _param_type,
+                            _$param = params[0];
+                          paramType = ((_param_type = _$param.type) === null || _param_type === void 0 ? void 0 : _param_type.getText(sourceFile)) || "unknown";
+                        }
+                        try {
+                          var typeString = `type QueryParams = ${paramType}`,
+                            model = TypeScriptToModel.Generate(typeString),
+                            valibotCode = 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;
-            })),
-            allQueries = queryResults.flat(),
-            queriesOutput = generateQueriesFile(allQueries),
-            queriesChanged = writeFileIfChanged(resolve(generatedDir, "queries.ts"), queriesOutput);
-          queriesChanged && 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 {
-          var {
-            execSync
-          } = await import("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;
+              })),
+              allQueries = queryResults.flat(),
+              clientQueriesOutput = generateClientQueriesFile(allQueries),
+              serverQueriesOutput = generateServerQueriesFile(allQueries),
+              clientChanged = writeFileIfChanged(resolve(generatedDir, "queries.client.ts"), clientQueriesOutput),
+              serverChanged = writeFileIfChanged(resolve(generatedDir, "queries.server.ts"), serverQueriesOutput);
+            clientChanged && console.info("  \u{1F4DD} Updated queries.client.ts"), serverChanged && console.info("  \u{1F4DD} Updated queries.server.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 {
+            var {
+              execSync
+            } = await import("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...
 `);
-      var chokidar = await import("chokidar"),
-        debounceTimer = null,
-        debouncedRegenerate = function (path, event) {
-          debounceTimer && clearTimeout(debounceTimer), console.info(`
+        var chokidar = await import("chokidar"),
+          debounceTimer = null,
+          debouncedRegenerate = function (path, event) {
+            debounceTimer && clearTimeout(debounceTimer), console.info(`
 ${event} ${path}`), debounceTimer = setTimeout(function () {
-            runGenerate();
-          }, 1e3);
-        },
-        watcher = chokidar.watch([modelsDir, queriesDir], {
-          persistent: !0,
-          ignoreInitial: !0
-        });
-      watcher.on("change", function (path) {
-        return debouncedRegenerate(path, "\u{1F4DD}");
-      }), watcher.on("add", function (path) {
-        return debouncedRegenerate(path, "\u2795");
-      }), watcher.on("unlink", function (path) {
-        return debouncedRegenerate(path, "\u{1F5D1}\uFE0F ");
-      }), await new Promise(function () {});
+              runGenerate();
+            }, 1e3);
+          },
+          watcher = chokidar.watch([modelsDir, queriesDir], {
+            persistent: !0,
+            ignoreInitial: !0
+          });
+        watcher.on("change", function (path) {
+          return debouncedRegenerate(path, "\u{1F4DD}");
+        }), watcher.on("add", function (path) {
+          return debouncedRegenerate(path, "\u2795");
+        }), watcher.on("unlink", function (path) {
+          return debouncedRegenerate(path, "\u{1F5D1}\uFE0F ");
+        }), await new Promise(function () {});
+      }
     }
-  }
-});
+  });
 function generateModelsFile(modelFiles) {
   var modelNames = modelFiles.map(function (f) {
       return basename(f, ".ts");
@@ -298,16 +300,39 @@ function generateTablesFile(modelFiles) {
 ${exports}
 `;
 }
-function generateQueriesFile(queries) {
-  var sortedQueries = [...queries].sort(function (a, b) {
-      return a.name.localeCompare(b.name);
-    }),
-    queryByFile = /* @__PURE__ */new Map(),
+function generateClientQueriesFile(queries) {
+  var sortedFiles = [...new Set(queries.map(function (q) {
+      return q.sourceFile;
+    }))].sort(),
+    imports = sortedFiles.map(function (file) {
+      return `import * as ${file}Queries from '../queries/${file}'`;
+    }).join(`
+`),
+    namespaces = sortedFiles.map(function (file) {
+      return `  ${file}: ${file}Queries,`;
+    }).join(`
+`);
+  return `/**
+ * auto-generated by: over-zero generate
+ *
+ * client-side query references 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.
+ */
+${imports}
+
+export const clientQueries = {
+${namespaces}
+}
+`;
+}
+function generateServerQueriesFile(queries) {
+  var queryByFile = /* @__PURE__ */new Map(),
     _iteratorNormalCompletion = !0,
     _didIteratorError = !1,
     _iteratorError = void 0;
   try {
-    for (var _iterator = sortedQueries[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = !0) {
+    for (var _iterator = queries[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = !0) {
       var q = _step.value;
       queryByFile.has(q.sourceFile) || queryByFile.set(q.sourceFile, []), queryByFile.get(q.sourceFile).push(q);
     }
@@ -320,15 +345,21 @@ function generateQueriesFile(queries) {
       if (_didIteratorError) throw _iteratorError;
     }
   }
-  var queryImports = Array.from(queryByFile.keys()).sort().map(function (file) {
+  var sortedFiles = Array.from(queryByFile.keys()).sort(),
+    queryImports = sortedFiles.map(function (file) {
       return `import * as ${file}Queries from '../queries/${file}'`;
     }).join(`
 `),
-    imports = `import * as v from 'valibot'
+    imports = `// auto-generated by: over-zero generate
+// server-side syncedQuery wrappers with validators
 import { syncedQuery } from '@rocicorp/zero'
+import * as v from 'valibot'
 ${queryImports}
 `,
-    syncedQueries = sortedQueries.map(function (q2) {
+    sortedQueries = [...queries].sort(function (a, b) {
+      return a.name.localeCompare(b.name);
+    }),
+    syncedQueryDefs = sortedQueries.map(function (q2) {
       var lines = q2.valibotCode.split(`
 `).filter(function (l) {
           return l.trim();
@@ -347,17 +378,35 @@ ${queryImports}
 `);
       }
       var wrappedValidator = validatorDef === "v.void()" ? "v.parser(v.tuple([]))" : `v.parser(v.tuple([${validatorDef}]))`,
+        namespacedName = `${q2.sourceFile}.${q2.name}`,
         queryFn = validatorDef === "v.void()" ? `() => {
-  return ${q2.sourceFile}Queries.${q2.name}()
-}` : `(arg) => {
-  return ${q2.sourceFile}Queries.${q2.name}(arg)
-}`;
-      return `export const ${q2.name} = syncedQuery('${q2.name}', ${wrappedValidator}, ${queryFn})`;
+    return ${q2.sourceFile}Queries.${q2.name}()
+  }` : `(arg) => {
+    return ${q2.sourceFile}Queries.${q2.name}(arg)
+  }`;
+      return `const ${q2.name}Synced = syncedQuery('${namespacedName}', ${wrappedValidator}, ${queryFn})`;
     }).join(`
 
+`),
+    namespaces = sortedFiles.map(function (file) {
+      var fileQueries = queryByFile.get(file).sort(function (a, b) {
+          return a.name.localeCompare(b.name);
+        }),
+        queryEntries = fileQueries.map(function (q2) {
+          return `    ${q2.name}: ${q2.name}Synced,`;
+        }).join(`
+`);
+      return `  ${file}: {
+${queryEntries}
+  },`;
+    }).join(`
 `);
-  return imports + `
-` + syncedQueries + `
+  return `${imports}
+${syncedQueryDefs}
+
+export const serverQueries = {
+${namespaces}
+}
 `;
 }
 function generateReadmeFile() {
@@ -370,7 +419,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
+- \`queries.client.ts\` - namespaced query references for client setup
+- \`queries.server.ts\` - namespaced syncedQuery wrappers for server setup
 
 ## usage guidelines
 
@@ -378,16 +428,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\`: