over-zero 0.0.10 → 0.0.13

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 vxrn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/cjs/{build/schema.cjs → builder.cjs}

@@ -18,11 +18,14 @@ var __export = (target, all) => {
 var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
   value: !0
 }), mod);
-var schema_exports = {};
-__export(schema_exports, {
-  permissions: () => import_readPermissions.readPermissions,
-  schema: () => import_schema.schema
+var builder_exports = {};
+__export(builder_exports, {
+  zql: () => zql
 });
-module.exports = __toCommonJS(schema_exports);
-var import_schema = require("../../../../src/data/schema"),
-  import_readPermissions = require("./readPermissions.cjs");
+module.exports = __toCommonJS(builder_exports);
+var import_state = require("./state.cjs");
+const zql = new Proxy({}, {
+  get(_target, prop) {
+    return (0, import_state.getZQL)()[prop];
+  }
+});

package/dist/cjs/{helpers/zeroEmitter.js → builder.js}

@@ -12,11 +12,15 @@ var __export = (target, all) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
-var zeroEmitter_exports = {};
-__export(zeroEmitter_exports, {
-  zeroEmitter: () => zeroEmitter
+var builder_exports = {};
+__export(builder_exports, {
+  zql: () => zql
 });
-module.exports = __toCommonJS(zeroEmitter_exports);
-var import_helpers = require("@vxrn/helpers");
-const zeroEmitter = (0, import_helpers.createEmitter)("zero", void 0);
-//# sourceMappingURL=zeroEmitter.js.map
+module.exports = __toCommonJS(builder_exports);
+var import_state = require("./state");
+const zql = new Proxy({}, {
+  get(_target, prop) {
+    return (0, import_state.getZQL)()[prop];
+  }
+});
+//# sourceMappingURL=builder.js.map

package/dist/cjs/builder.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/builder.ts"],
+  "mappings": ";;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAAuB;AAGhB,MAAM,MAAM,IAAI,MAAM,CAAC,GAAmB;AAAA,EAC/C,IAAI,SAAS,MAAM;AAEjB,eADU,qBAAO,EACC,IAAI;AAAA,EACxB;AACF,CAAC;",
+  "names": []
+}

package/dist/cjs/builder.native.js

@@ -0,0 +1,35 @@
+"use strict";
+
+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 builder_exports = {};
+__export(builder_exports, {
+  zql: () => zql
+});
+module.exports = __toCommonJS(builder_exports);
+var import_state = require("./state.native.js"),
+  zql = new Proxy({}, {
+    get(_target, prop) {
+      var b = (0, import_state.getZQL)();
+      return b[prop];
+    }
+  });
+//# sourceMappingURL=builder.native.js.map

package/dist/cjs/builder.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["__toCommonJS","mod","__copyProps","__defProp","value","builder_exports","__export","zql","module","exports","import_state","require","Proxy","get","_target","prop","b","getZQL"],"sources":["../../src/builder.ts"],"sourcesContent":[null],"mappings":";;;;;;;;;;;;;;;;;;;AAAA,IAAAA,YAAA,GAAAC,GAAA,IAAAC,WAAA,CAAAC,SAAA;EAAAC,KAAA;AAAA,IAAAH,GAAA;AAAA,IAAAI,eAAA;AAAAC,QAAA,CAAAD,eAAA;EAAAE,GAAA,EAAAA,CAAA,KAAAA;AAAA;AAAAC,MAAA,CAAAC,OAAA,GAAAT,YAAuB,CAAAK,eAAA;AAGhB,IAAAK,YAAgB,GAAAC,OAA0B;EAAAJ,GAAA,OAAAK,KAAA;IAC/CC,IAAIC,OAAA,EAASC,IAAA,EAAM;MAEjB,IAAAC,CAAA,OADUN,YAAA,CAAAO,MAAA,EAAO,CACC;MACpB,OAAAD,CAAA,CAAAD,IAAA;IACD","ignoreList":[]}

package/dist/cjs/cli.cjs

@@ -0,0 +1,299 @@
+#!/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_model = require("@sinclair/typebox-codegen/model"),
+  import_typescript = require("@sinclair/typebox-codegen/typescript"),
+  import_citty = require("citty"),
+  import_node_fs = require("node:fs"),
+  import_node_path = require("node:path"),
+  ts = __toESM(require("typescript"), 1);
+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,
+        writeFileSync: writeFileSync2
+      } = 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`);
+  }
+});
+const 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 () => {
+        (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] = await Promise.all([Promise.resolve(generateModelsFile(allModelFiles)), Promise.resolve(generateTypesFile(filesWithSchema)), Promise.resolve(generateTablesFile(filesWithSchema))]);
+        if (await Promise.all([Promise.resolve((0, import_node_fs.writeFileSync)((0, import_node_path.resolve)(generatedDir, "models.ts"), modelsOutput, "utf-8")), Promise.resolve((0, import_node_fs.writeFileSync)((0, import_node_path.resolve)(generatedDir, "types.ts"), typesOutput, "utf-8")), Promise.resolve((0, import_node_fs.writeFileSync)((0, import_node_path.resolve)(generatedDir, "tables.ts"), tablesOutput, "utf-8"))]), (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(),
+            queriesOutput = generateQueriesFile(allQueries);
+          (0, import_node_fs.writeFileSync)((0, import_node_path.resolve)(generatedDir, "queries.ts"), queriesOutput, "utf-8"), 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 {
+          const {
+            execSync
+          } = await import("node: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...
+`);
+      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 '~/data/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 '~/data/models/${name}'`).join(`
+`)}
+`;
+}
+function generateQueriesFile(queries) {
+  const sortedQueries = [...queries].sort((a, b) => a.name.localeCompare(b.name)),
+    queryByFile = /* @__PURE__ */new Map();
+  for (const q of sortedQueries) queryByFile.has(q.sourceFile) || queryByFile.set(q.sourceFile, []), queryByFile.get(q.sourceFile).push(q);
+  const imports = `import * as v from 'valibot'
+import { syncedQuery } from '@rocicorp/zero'
+${Array.from(queryByFile.keys()).sort().map(file => `import * as ${file}Queries from '../queries/${file}'`).join(`
+`)}
+`,
+    syncedQueries = sortedQueries.map(q => {
+      const lines = q.valibotCode.split(`
+`).filter(l => l.trim()),
+        schemaLineIndex = lines.findIndex(l => l.startsWith("export const QueryParams"));
+      let validatorDef = "v.void()";
+      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(`
+`);
+      }
+      const wrappedValidator = validatorDef === "v.void()" ? "v.parser(v.tuple([]))" : `v.parser(v.tuple([${validatorDef}]))`,
+        queryFn = validatorDef === "v.void()" ? `() => {
+  return ${q.sourceFile}Queries.${q.name}()
+}` : `(arg) => {
+  return ${q.sourceFile}Queries.${q.name}(arg)
+}`;
+      return `export const ${q.name} = syncedQuery('${q.name}', ${wrappedValidator}, ${queryFn})`;
+    }).join(`
+
+`);
+  return imports + `
+` + syncedQueries + `
+`;
+}
+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);