over-zero 0.0.62 → 0.0.63

package/dist/cjs/cli.cjs

@@ -0,0 +1,405 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf,
+  __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+    get: () => from[key],
+    enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+  });
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+// If the importer is in node compatibility mode or this is not an ESM
+// file that has been converted to a CommonJS file using a Babel-
+// compatible transform (i.e. "__esModule" has not been set), then set
+// "default" to the CommonJS "module.exports" for node compatibility.
+isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+  value: mod,
+  enumerable: !0
+}) : target, mod));
+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"),
+  ts = __toESM(require("typescript"), 1);
+function writeFileIfChanged(filePath, content) {
+  try {
+    if ((0, import_node_fs.existsSync)(filePath) && (0, import_node_fs.readFileSync)(filePath, "utf-8") === content) return !1;
+  } catch {}
+  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
+        } = 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`);
+    }
+  }),
+  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"
+      },
+      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
+      }
+    },
+    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 options => {
+          const silent = options?.silent ?? !1;
+          (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 && !silent && 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(),
+              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),
+              queryFilesChanged = (groupedChanged ? 1 : 0) + (syncedChanged ? 1 : 0),
+              totalFilesChanged = filesChanged + queryFilesChanged;
+            if (totalFilesChanged > 0 && !silent && (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`)), totalFilesChanged > 0 && !silent && args.after) try {
+              const {
+                execSync
+              } = await import("node:child_process");
+              execSync(args.after, {
+                stdio: "inherit"
+              });
+            } catch (err) {
+              console.error(`Error running after command: ${err}`);
+            }
+          } else if (filesChanged > 0 && !silent && console.info(`\u2713 ${allModelFiles.length} models (${filesWithSchema.length} schemas)`), filesChanged > 0 && !silent && 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({
+        silent: args.watch
+      }), args.watch) {
+        console.info(`\u{1F440} watching...
+`);
+        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(() => {});
+      }
+    }
+  });
+function generateModelsFile(modelFiles) {
+  const modelNames = modelFiles.map(f => (0, import_node_path.basename)(f, ".ts")).sort(),
+    getImportName = name => name === "user" ? "userPublic" : name,
+    imports = modelNames.map(name => `import * as ${getImportName(name)} from '../models/${name}'`).join(`
+`),
+    modelsObj = `export const models = {
+${[...modelNames].sort((a, b) => getImportName(a).localeCompare(getImportName(b))).map(name => `  ${getImportName(name)},`).join(`
+`)}
+}`;
+  return `// auto-generated by: over-zero generate
+${imports}
+
+${modelsObj}
+`;
+}
+function generateTypesFile(modelFiles) {
+  const modelNames = modelFiles.map(f => (0, import_node_path.basename)(f, ".ts")).sort(),
+    getSchemaName = name => name === "user" ? "userPublic" : name;
+  return `import type { TableInsertRow, TableUpdateRow } from 'over-zero'
+import type * as schema from './tables'
+
+${modelNames.map(name => {
+    const pascalName = name.charAt(0).toUpperCase() + name.slice(1),
+      schemaName = getSchemaName(name);
+    return `export type ${pascalName} = TableInsertRow<typeof schema.${schemaName}>
+export type ${pascalName}Update = TableUpdateRow<typeof schema.${schemaName}>`;
+  }).join(`
+
+`)}
+`;
+}
+function generateTablesFile(modelFiles) {
+  const modelNames = modelFiles.map(f => (0, import_node_path.basename)(f, ".ts")).sort(),
+    getExportName = name => name === "user" ? "userPublic" : name;
+  return `// auto-generated by: over-zero generate
+// this is separate from models as otherwise you end up with circular types :/
+
+${modelNames.map(name => `export { schema as ${getExportName(name)} } from '../models/${name}'`).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 query definitions with validators
+import { defineQuery, defineQueries } from '@rocicorp/zero'
+import * as v from 'valibot'
+import * as Queries from './groupedQueries'
+`,
+    namespaceDefs = 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 = "";
+        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(`
+`);
+        }
+        if (q.params === "void" || !validatorDef) return `  ${q.name}: defineQuery(() => Queries.${file}.${q.name}()),`;
+        const indentedValidator = validatorDef.split(`
+`).map((line, i) => i === 0 ? line : `    ${line}`).join(`
+`);
+        return `  ${q.name}: defineQuery(
+    ${indentedValidator},
+    ({ args }) => Queries.${file}.${q.name}(args)
+  ),`;
+      }).join(`
+`);
+      return `const ${file} = {
+${queryDefs}
+}`;
+    }).join(`
+
+`),
+    queriesObject = sortedFiles.map(file => `  ${file},`).join(`
+`);
+  return `${imports}
+${namespaceDefs}
+
+export const queries = defineQueries({
+${queriesObject}
+})
+`;
+}
+function generateReadmeFile() {
+  return `# generated
+
+this folder is auto-generated by over-zero. do not edit files here directly.
+
+## what's generated
+
+- \`models.ts\` - exports all models from ../models
+- \`types.ts\` - typescript types derived from table schemas
+- \`tables.ts\` - exports table schemas for type inference
+- \`groupedQueries.ts\` - namespaced query re-exports for client setup
+- \`syncedQueries.ts\` - namespaced syncedQuery wrappers for server setup
+
+## usage guidelines
+
+**do not import generated files outside of the data folder.**
+
+### queries
+
+write your queries as plain functions in \`../queries/\` and import them directly:
+
+\`\`\`ts
+// \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\`:
+
+\`\`\`ts
+// \u274C okay but not preferred
+import type { Message } from '~/data/generated/types'
+
+// \u2705 better - re-export from types.ts
+import type { Message } from '~/data/types'
+\`\`\`
+
+## regeneration
+
+files are regenerated when you run:
+
+\`\`\`bash
+bun over-zero generate
+\`\`\`
+
+or in watch mode:
+
+\`\`\`bash
+bun over-zero generate --watch
+\`\`\`
+
+## more info
+
+see the [over-zero readme](./node_modules/over-zero/README.md) for full documentation.
+`;
+}
+const main = (0, import_citty.defineCommand)({
+  meta: {
+    name: "over-zero",
+    description: "Over-zero CLI tools"
+  },
+  subCommands: {
+    generate,
+    "generate-queries": generateQueries
+  }
+});
+(0, import_citty.runMain)(main);