on-zero 0.4.1 → 0.4.2

package/dist/cjs/generate-helpers.cjs

@@ -0,0 +1,309 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __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 __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: !0
+}), mod);
+var generate_helpers_exports = {};
+__export(generate_helpers_exports, {
+  columnTypeToValibot: () => columnTypeToValibot,
+  extractValibotExpression: () => extractValibotExpression,
+  formatObjectKey: () => formatObjectKey,
+  generateGroupedQueriesFile: () => generateGroupedQueriesFile,
+  generateModelsFile: () => generateModelsFile,
+  generateReadmeFile: () => generateReadmeFile,
+  generateSyncedMutationsFile: () => generateSyncedMutationsFile,
+  generateSyncedQueriesFile: () => generateSyncedQueriesFile,
+  generateTablesFile: () => generateTablesFile,
+  generateTypesFile: () => generateTypesFile,
+  getModelImportName: () => getModelImportName,
+  parseColumnType: () => parseColumnType,
+  parseTypeString: () => parseTypeString,
+  schemaColumnsToValibot: () => schemaColumnsToValibot,
+  shouldSkipObjectKey: () => shouldSkipObjectKey
+});
+module.exports = __toCommonJS(generate_helpers_exports);
+function shouldSkipObjectKey(name) {
+  return name.startsWith("__@");
+}
+function formatObjectKey(name) {
+  return /^[$A-Z_a-z][$\w]*$/.test(name) ? name : JSON.stringify(name);
+}
+function getModelImportName(name) {
+  return name === "user" ? "userPublic" : name;
+}
+function parseTypeString(type) {
+  if (type = type.trim(), type === "string") return "v.string()";
+  if (type === "number") return "v.number()";
+  if (type === "boolean") return "v.boolean()";
+  if (type === "void" || type === "undefined") return "v.void_()";
+  if (type === "null") return "v.null_()";
+  if (type === "any" || type === "unknown") return "v.unknown()";
+  if (type.startsWith("{") && type.endsWith("}")) {
+    const inner = type.slice(1, -1).trim();
+    if (!inner) return "v.object({})";
+    const normalized = inner.replace(/\n/g, "; ").replace(/;\s*;/g, ";"),
+      entries = [];
+    for (const part of normalized.split(";")) {
+      const trimmed = part.trim().replace(/,\s*$/, "");
+      if (!trimmed) continue;
+      const match = trimmed.match(/^(?:readonly\s+)?(\w+)(\?)?:\s*(.+)$/);
+      if (!match) continue;
+      const [, name, opt, typeStr] = match,
+        parsed = parseTypeString(typeStr.trim());
+      if (!parsed) return null;
+      let val = parsed;
+      opt && (val = `v.optional(${val})`), entries.push(`${formatObjectKey(name)}: ${val}`);
+    }
+    return entries.length === 0 ? "v.object({})" : `v.object({
+    ${entries.join(`,
+    `)},
+  })`;
+  }
+  if (type.endsWith("[]")) {
+    const inner = parseTypeString(type.slice(0, -2).trim());
+    return inner ? `v.array(${inner})` : null;
+  }
+  return null;
+}
+function generateModelsFile(modelNames, modelsDirName) {
+  const sorted = [...modelNames].sort(),
+    imports = sorted.map(name => `import * as ${getModelImportName(name)} from '../${modelsDirName}/${name}'`).join(`
+`),
+    modelsObj = `export const models = {
+${[...sorted].sort((a, b) => getModelImportName(a).localeCompare(getModelImportName(b))).map(name => `  ${getModelImportName(name)},`).join(`
+`)}
+}`;
+  return `// auto-generated by: on-zero generate
+${imports}
+
+${modelsObj}
+`;
+}
+function generateTypesFile(modelNames) {
+  return `import type { TableInsertRow, TableUpdateRow } from 'on-zero'
+import type * as schema from './tables'
+
+${[...modelNames].sort().map(name => {
+    const pascalName = name.charAt(0).toUpperCase() + name.slice(1),
+      schemaName = getModelImportName(name);
+    return `export type ${pascalName} = TableInsertRow<typeof schema.${schemaName}>
+export type ${pascalName}Update = TableUpdateRow<typeof schema.${schemaName}>`;
+  }).join(`
+
+`)}
+`;
+}
+function generateTablesFile(modelNames, modelsDirName) {
+  return `// auto-generated by: on-zero generate
+
+${[...modelNames].sort().map(name => `export { schema as ${getModelImportName(name)} } from '../${modelsDirName}/${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
+- \`syncedMutations.ts\` - valibot validators for mutation args (server auto-validation)
+
+## 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 validatorDef = q.valibotCode.trim();
+        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 columnTypeToValibot(col) {
+  let base = "v.string()";
+  switch (col.type) {
+    case "string":
+      base = "v.string()";
+      break;
+    case "number":
+      base = "v.number()";
+      break;
+    case "boolean":
+      base = "v.boolean()";
+      break;
+    case "json":
+      base = "v.unknown()";
+      break;
+    case "enum":
+      base = "v.string()";
+      break;
+  }
+  return col.optional ? `v.optional(v.nullable(${base}))` : base;
+}
+function schemaColumnsToValibot(columns, primaryKeys, mode) {
+  const entries = [];
+  if (mode === "delete") for (const pk of primaryKeys) {
+    const col = columns[pk];
+    col && entries.push(`${formatObjectKey(pk)}: ${columnTypeToValibot({
+      ...col,
+      optional: !1
+    })}`);
+  } else if (mode === "update") for (const [name, col] of Object.entries(columns)) primaryKeys.includes(name) ? entries.push(`${formatObjectKey(name)}: ${columnTypeToValibot({
+    ...col,
+    optional: !1
+  })}`) : entries.push(`${formatObjectKey(name)}: ${columnTypeToValibot({
+    ...col,
+    optional: !0
+  })}`);else for (const [name, col] of Object.entries(columns)) entries.push(`${formatObjectKey(name)}: ${columnTypeToValibot(col)}`);
+  return `v.object({
+    ${entries.join(`,
+    `)},
+  })`;
+}
+function extractValibotExpression(valibotCode) {
+  return valibotCode.trim() || "v.unknown()";
+}
+function parseColumnType(initText) {
+  const optional = initText.includes(".optional()");
+  let type = "string";
+  return initText.startsWith("number(") ? type = "number" : initText.startsWith("boolean(") ? type = "boolean" : initText.startsWith("json(") || initText.startsWith("json<") ? type = "json" : initText.startsWith("enumeration(") && (type = "enum"), {
+    type,
+    optional,
+    customType: void 0
+  };
+}
+function generateSyncedMutationsFile(modelMutations) {
+  return `// auto-generated by: on-zero generate
+// mutation validators derived from model schemas and handler types
+import * as v from 'valibot'
+
+export const mutationValidators = {
+${[...modelMutations].sort((a, b) => a.modelName.localeCompare(b.modelName)).map(model => {
+    const entries = [];
+    if (model.hasCRUD && Object.keys(model.columns).length > 0) for (const mode of ["insert", "update", "delete"]) if (model.custom.some(m => m.name === mode)) {
+      const customMut = model.custom.find(m => m.name === mode);
+      customMut.valibotCode ? entries.push(`    ${mode}: ${extractValibotExpression(customMut.valibotCode)},`) : entries.push(`    ${mode}: ${schemaColumnsToValibot(model.columns, model.primaryKeys, mode)},`);
+    } else entries.push(`    ${mode}: ${schemaColumnsToValibot(model.columns, model.primaryKeys, mode)},`);
+    for (const mut of model.custom) if (!(model.hasCRUD && ["insert", "update", "delete", "upsert"].includes(mut.name))) {
+      if (mut.paramType === "void" || !mut.valibotCode) {
+        entries.push(`    ${mut.name}: v.void_(),`);
+        continue;
+      }
+      entries.push(`    ${mut.name}: ${extractValibotExpression(mut.valibotCode)},`);
+    }
+    return `  ${model.modelName}: {
+${entries.join(`
+`)}
+  },`;
+  }).join(`
+`)}
+}
+`;
+}