on-zero 0.1.21 → 0.1.23

package/dist/cjs/generate.cjs

@@ -0,0 +1,370 @@
+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 __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __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)),
+  __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+    value: !0
+  }), mod);
+var generate_exports = {};
+__export(generate_exports, {
+  generate: () => generate,
+  watch: () => watch
+});
+module.exports = __toCommonJS(generate_exports);
+var import_node_crypto = require("node:crypto"),
+  import_node_fs = require("node:fs"),
+  import_node_path = require("node:path");
+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);
+}
+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 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.
+`;
+}
+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}
+})
+`;
+}
+async function generate(options) {
+  const {
+      dir,
+      after,
+      silent
+    } = options,
+    baseDir = (0, import_node_path.resolve)(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");
+  (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 = allModelFiles.filter(f => (0, import_node_fs.readFileSync)((0, import_node_path.resolve)(modelsDir, f), "utf-8").includes("export const schema = table("));
+  let filesChanged = [writeFileIfChanged((0, import_node_path.resolve)(generatedDir, "models.ts"), generateModelsFile(allModelFiles)), writeFileIfChanged((0, import_node_path.resolve)(generatedDir, "types.ts"), generateTypesFile(filesWithSchema)), writeFileIfChanged((0, import_node_path.resolve)(generatedDir, "tables.ts"), generateTablesFile(filesWithSchema)), writeFileIfChanged((0, import_node_path.resolve)(generatedDir, "README.md"), generateReadmeFile())].filter(Boolean).length,
+    queryCount = 0;
+  if ((0, import_node_fs.existsSync)(queriesDir)) {
+    const ts = await import("typescript"),
+      {
+        ModelToValibot
+      } = await import("@sinclair/typebox-codegen/model"),
+      {
+        TypeScriptToModel
+      } = await import("@sinclair/typebox-codegen/typescript"),
+      queryFiles = (0, import_node_fs.readdirSync)(queriesDir).filter(f => f.endsWith(".ts")),
+      allQueries = [];
+    for (const file of queryFiles) {
+      const filePath = (0, import_node_path.resolve)(queriesDir, file),
+        fileBaseName = (0, import_node_path.basename)(file, ".ts");
+      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 = TypeScriptToModel.Generate(typeString),
+                  valibotCode = ModelToValibot.Generate(model);
+                allQueries.push({
+                  name,
+                  params: paramType,
+                  valibotCode,
+                  sourceFile: fileBaseName
+                });
+              } catch (err) {
+                silent || console.error(`\u2717 ${name}: ${err}`);
+              }
+            }
+          }
+        });
+      } catch (err) {
+        silent || console.error(`Error processing ${file}:`, err);
+      }
+    }
+    queryCount = allQueries.length;
+    const groupedChanged = writeFileIfChanged((0, import_node_path.resolve)(generatedDir, "groupedQueries.ts"), generateGroupedQueriesFile(allQueries)),
+      syncedChanged = writeFileIfChanged((0, import_node_path.resolve)(generatedDir, "syncedQueries.ts"), generateSyncedQueriesFile(allQueries));
+    groupedChanged && filesChanged++, syncedChanged && filesChanged++;
+  }
+  if (filesChanged > 0 && !silent && console.info(`\u2713 ${allModelFiles.length} models (${filesWithSchema.length} schemas)${queryCount ? `, ${queryCount} queries` : ""}`), filesChanged > 0 && after) {
+    const {
+      execSync
+    } = await import("node:child_process");
+    try {
+      execSync(after, {
+        stdio: "inherit",
+        env: {
+          ...process.env,
+          ON_ZERO_GENERATED_DIR: generatedDir
+        }
+      });
+    } catch (err) {
+      silent || console.error(`Error running after command: ${err}`);
+    }
+  }
+  return saveCache(), {
+    filesChanged,
+    modelCount: allModelFiles.length,
+    schemaCount: filesWithSchema.length,
+    queryCount
+  };
+}
+async function watch(options) {
+  const {
+      dir,
+      debounce = 1e3
+    } = options,
+    baseDir = (0, import_node_path.resolve)(dir),
+    modelsDir = (0, import_node_path.resolve)(baseDir, "models"),
+    queriesDir = (0, import_node_path.resolve)(baseDir, "queries"),
+    generatedDir = (0, import_node_path.resolve)(baseDir, "generated");
+  await generate({
+    ...options,
+    silent: !0
+  }), 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(() => {
+        generate({
+          ...options,
+          silent: !1
+        });
+      }, debounce);
+    },
+    watcher = chokidar.watch([modelsDir, queriesDir], {
+      persistent: !0,
+      ignoreInitial: !0,
+      ignored: [generatedDir]
+    });
+  return watcher.on("change", path => debouncedRegenerate(path, "\u{1F4DD}")), watcher.on("add", path => debouncedRegenerate(path, "\u2795")), watcher.on("unlink", path => debouncedRegenerate(path, "\u{1F5D1}\uFE0F ")), watcher;
+}