@sequenceholdings/orm 0.1.3 → 2.0.0

package/dist/cli.cjs

@@ -1222,7 +1222,12 @@ async function loadNamespaceFromDir(dir, options = {}) {
   const jiti$1 = jiti.createJiti((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('cli.cjs', document.baseURI).href)), {
     interopDefault: true,
     fsCache: false,
-    ...options.ormModulePath !== void 0 ? { alias: { "@sequenceholdings/orm": options.ormModulePath } } : {}
+    ...options.ormModulePath !== void 0 ? {
+      alias: {
+        "@sequenceholdings/orm": options.ormModulePath,
+        "@sequenceholdings/orm/authoring": options.ormModulePath
+      }
+    } : {}
   });
   const context = beginAuthoringContext();
   try {
@@ -1313,7 +1318,7 @@ var manifestOperationSchema = zod.z.object({
   kind: zod.z.enum(["query", "mutation"]),
   requires: manifestRequiresSchema
 });
-zod.z.object({
+var operationsManifestSchema = zod.z.object({
   manifestVersion: zod.z.literal(MANIFEST_VERSION),
   schemaHash: zod.z.string().min(1),
   opsHash: zod.z.string().regex(OP_HASH_RE),
@@ -1924,6 +1929,10 @@ var Parser = class {
       this.expect("rparen", "')'");
       return inner;
     }
+    if (this.peekKeyword("true") || this.peekKeyword("false")) {
+      const token = this.advance();
+      return { kind: "literal", value: token.value === "true" };
+    }
     if (this.peekKeyword("capability") || this.peekKeyword("role")) {
       const fn = this.peek().value;
       const node = this.parseBooleanCall(fn);
@@ -2107,6 +2116,8 @@ var PolicyCompiler = class {
   }
   compile(node, table, depth) {
     switch (node.kind) {
+      case "literal":
+        return { kind: "const", value: node.value };
       case "and":
       case "or":
         return { kind: node.kind, operands: node.operands.map((operand) => this.compile(operand, table, depth)) };
@@ -7298,6 +7309,8 @@ var USAGE = `usage:
   seq-studio orm apply [dir] -e <env>    author the migration, register, apply, and refresh the generated outputs (the everyday command)
   seq-studio orm apply --dry-run -e <env>  rehearse the migration on a copy of the environment's real data, then discard it (no real apply)
   seq-studio orm apply --no-create -e <env>  apply only if the namespace is already registered (CI guard; never provisions a new namespace)
+  seq-studio orm execute <operation> [dir] --variables-file <file> -e <env>
+                                        execute one named persisted operation as the signed-in caller
   seq-studio orm diff [dir]              write/verify the committed migration standalone (--check is the offline CI gate; --allow-destructive consents; --rebase records a v1 -> v2 conversion as a verified no-op)
   seq-studio orm migrate-from-yaml <dir> convert a v1 YAML namespace to the v2 TypeScript format (migrations/ preserved)
 
@@ -7321,6 +7334,10 @@ async function runCli(argv) {
     console.log(USAGE);
     return command ? 0 : 1;
   }
+  if (rest.includes("--help") || rest.includes("-h")) {
+    console.log(USAGE);
+    return 0;
+  }
   try {
     switch (command) {
       case "init":
@@ -7358,6 +7375,8 @@ async function runCli(argv) {
         const dir = positional(rest) ?? ".";
         return await detectProjectFormat(dir) === "v2" ? await applyV2Command(rest, dir) : await applyCommand(rest);
       }
+      case "execute":
+        return await executeV2Command(rest);
       default:
         console.error(`unknown command: ${command}`);
         console.log(USAGE);
@@ -7368,13 +7387,14 @@ async function runCli(argv) {
     return 1;
   }
 }
+var NON_DEFINITION_YAML_FILES = /* @__PURE__ */ new Set(["pnpm-lock.yaml", "pnpm-workspace.yaml"]);
 async function detectProjectFormat(dir) {
   const entries = await promises.readdir(dir, { withFileTypes: true }).catch(() => {
     throw new OrmDefinitionError(`namespace directory not found: ${dir}`);
   });
   const hasConfig = entries.some((entry) => entry.isFile() && entry.name === NAMESPACE_CONFIG_FILE);
   const hasYaml = entries.some(
-    (entry) => entry.isFile() && DEFINITION_FILE_EXTENSIONS.some((extension) => entry.name.endsWith(extension))
+    (entry) => entry.isFile() && !NON_DEFINITION_YAML_FILES.has(entry.name) && DEFINITION_FILE_EXTENSIONS.some((extension) => entry.name.endsWith(extension))
   );
   if (hasConfig && hasYaml) {
     throw new OrmDefinitionError(
@@ -7569,6 +7589,79 @@ async function runConsumerCodegen(dir) {
   console.log(`ran consumer graphql-codegen (${CODEGEN_CONFIG_FILE})`);
   return 0;
 }
+function isVariablesObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function parseExecuteArgs(rest) {
+  const args = [...rest];
+  const variablesIndex = args.indexOf("--variables-file");
+  if (variablesIndex === -1) {
+    throw new OrmDefinitionError("execute requires --variables-file <file>");
+  }
+  const variablesFile = args[variablesIndex + 1];
+  if (!variablesFile) {
+    throw new OrmDefinitionError("execute requires --variables-file <file>");
+  }
+  args.splice(variablesIndex, 2);
+  const envIndex = args.indexOf("--env");
+  if (envIndex !== -1) args.splice(envIndex, 2);
+  if (args.some((arg) => arg.startsWith("-"))) {
+    throw new OrmDefinitionError("execute accepts only <operation>, [dir], --variables-file, and --env");
+  }
+  const operation = args[0];
+  if (!operation || args.length > 2) {
+    throw new OrmDefinitionError("usage: seq-studio orm execute <operation> [dir] --variables-file <file> -e <env>");
+  }
+  return {
+    operation,
+    dir: args[1] ?? ".",
+    variablesFile
+  };
+}
+async function readExecuteVariables(variablesFile) {
+  let parsed;
+  try {
+    parsed = JSON.parse(await promises.readFile(path.resolve(variablesFile), "utf8"));
+  } catch (error) {
+    throw new OrmDefinitionError(
+      `could not read JSON variables from ${variablesFile}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  if (!isVariablesObject(parsed)) {
+    throw new OrmDefinitionError("--variables-file must contain a JSON object");
+  }
+  return parsed;
+}
+async function executeV2Command(rest) {
+  const { dir, operation, variablesFile } = parseExecuteArgs(rest);
+  if (await detectProjectFormat(dir) !== "v2") {
+    throw new OrmDefinitionError("execute supports TypeScript ORM v2 namespaces only");
+  }
+  const loaded = await loadV2(dir);
+  const manifestPath = path.join(dir, OPERATIONS_MANIFEST_FILE);
+  let manifest;
+  try {
+    manifest = operationsManifestSchema.parse(JSON.parse(await promises.readFile(manifestPath, "utf8")));
+  } catch (error) {
+    throw new OrmDefinitionError(
+      `could not read ${OPERATIONS_MANIFEST_FILE}: ${error instanceof Error ? error.message : String(error)} \u2014 run \`seq-studio orm generate ${dir}\` first`
+    );
+  }
+  const selected = manifest.operations[operation];
+  if (!selected) {
+    throw new OrmDefinitionError(
+      `operation "${operation}" is not in ${OPERATIONS_MANIFEST_FILE}; run \`seq-studio orm generate ${dir}\` after editing GraphQL documents`
+    );
+  }
+  const variables = await readExecuteVariables(variablesFile);
+  const response = await apiRequestStrict(
+    "POST",
+    `/_data/v2/${loaded.canonical.namespace}`,
+    { op: selected.hash, variables }
+  );
+  console.log(JSON.stringify(response, null, 2));
+  return 0;
+}
 async function validateV2Command(dir) {
   const compiled = await compileV2Project(dir);
   printDiagnostics(compiled.ok ? compiled.project.diagnostics : compiled.diagnostics);