on-zero 0.1.22 → 0.1.23

package/dist/cjs/cli.cjs

@@ -1,131 +1,8 @@
 #!/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_crypto = require("node:crypto"),
-  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"),
+var import_node_path = require("node:path"),
   import_citty = require("citty"),
-  ts = __toESM(require("typescript"), 1);
-const hash = s => (0, import_node_crypto.createHash)("sha256").update(s).digest("hex");
-let generateCache = {},
-  generateCachePath = "";
-function getCacheDir() {
-  let dir = process.cwd();
-  for (; dir !== "/";) {
-    const nm = (0, import_node_path.resolve)(dir, "node_modules");
-    if ((0, import_node_fs.existsSync)(nm)) {
-      const cacheDir = (0, import_node_path.resolve)(nm, ".on-zero");
-      return (0, import_node_fs.existsSync)(cacheDir) || (0, import_node_fs.mkdirSync)(cacheDir, {
-        recursive: !0
-      }), cacheDir;
-    }
-    dir = (0, import_node_path.resolve)(dir, "..");
-  }
-  return null;
-}
-function loadCache() {
-  const cacheDir = getCacheDir();
-  if (cacheDir) {
-    generateCachePath = (0, import_node_path.resolve)(cacheDir, "generate-cache.json");
-    try {
-      generateCache = JSON.parse((0, import_node_fs.readFileSync)(generateCachePath, "utf-8"));
-    } catch {
-      generateCache = {};
-    }
-  }
-}
-function saveCache() {
-  generateCachePath && (0, import_node_fs.writeFileSync)(generateCachePath, JSON.stringify(generateCache) + `
-`, "utf-8");
-}
-function writeFileIfChanged(filePath, content) {
-  const contentHash = hash(content);
-  return generateCache[filePath] === contentHash && (0, import_node_fs.existsSync)(filePath) ? !1 : ((0, import_node_fs.writeFileSync)(filePath, content, "utf-8"), generateCache[filePath] = contentHash, !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)({
+  import_generate = require("./generate.cjs");
+const generateCommand = (0, import_citty.defineCommand)({
     meta: {
       name: "generate",
       description: "Generate models, types, tables, and query validators"
@@ -152,304 +29,20 @@ const generateQueries = (0, import_citty.defineCommand)({
     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,
-            runAfter = options?.runAfter ?? !silent;
-          (0, import_node_fs.existsSync)(generatedDir) || (0, import_node_fs.mkdirSync)(generatedDir, {
-            recursive: !0
-          }), loadCache();
-          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 && runAfter && args.after) try {
-              const {
-                execSync
-              } = await import("node:child_process");
-              execSync(args.after, {
-                stdio: "inherit",
-                env: {
-                  ...process.env,
-                  ON_ZERO_GENERATED_DIR: generatedDir
-                }
-              });
-            } catch (err) {
-              console.error(`Error running after command: ${err}`);
-            }
-            saveCache();
-          } else {
-            if (filesChanged > 0 && !silent && console.info(`\u2713 ${allModelFiles.length} models (${filesWithSchema.length} schemas)`), filesChanged > 0 && runAfter && args.after) try {
-              const {
-                execSync
-              } = await import("node:child_process");
-              execSync(args.after, {
-                stdio: "inherit",
-                env: {
-                  ...process.env,
-                  ON_ZERO_GENERATED_DIR: generatedDir
-                }
-              });
-            } catch (err) {
-              console.error(`Error running after command: ${err}`);
-            }
-            saveCache();
-          }
-        };
-      if (await runGenerate({
-        silent: args.watch,
-        runAfter: !0
-      }), 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,
-            ignored: [generatedDir]
-          });
-        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(() => {});
-      }
+      const opts = {
+        dir: (0, import_node_path.resolve)(args.dir),
+        after: args.after
+      };
+      args.watch ? (await (0, import_generate.watch)(opts), await new Promise(() => {})) : await (0, import_generate.generate)(opts);
+    }
+  }),
+  main = (0, import_citty.defineCommand)({
+    meta: {
+      name: "on-zero",
+      description: "on-zero CLI tools"
+    },
+    subCommands: {
+      generate: generateCommand
     }
   });
-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: on-zero generate
-${imports}
-
-${modelsObj}
-
-if (import.meta.hot) {
-  import.meta.hot.accept()
-}
-`;
-}
-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 'on-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: on-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: on-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: on-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 on-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 on-zero generate
-\`\`\`
-
-or in watch mode:
-
-\`\`\`bash
-bun on-zero generate --watch
-\`\`\`
-
-## more info
-
-see the [on-zero readme](./node_modules/on-zero/README.md) for full documentation.
-`;
-}
-const main = (0, import_citty.defineCommand)({
-  meta: {
-    name: "on-zero",
-    description: "on-zero CLI tools"
-  },
-  subCommands: {
-    generate,
-    "generate-queries": generateQueries
-  }
-});
 (0, import_citty.runMain)(main);