@crustjs/validate 0.0.1 → 0.0.2

package/dist/effect/index.js

@@ -1,95 +1,19 @@
 // @bun
 import {
-  buildArgDefinitions,
-  buildFlagDefinitions,
-  buildRunHandler,
+  buildValidatedRunner,
   normalizeIssues
-} from "../shared/chunk-zfhm7pmv.js";
-
-// src/effect/command.ts
-import { defineCommand } from "@crustjs/core";
-import { either, runSync } from "effect/Effect";
-import * as Either from "effect/Either";
-import * as ParseResult from "effect/ParseResult";
-import { decodeUnknown } from "effect/Schema";
-
-// src/effect/definitions.ts
-import { CrustError as CrustError2 } from "@crustjs/core";
-import { encodedSchema } from "effect/Schema";
+} from "../shared/chunk-p8pzhj6c.js";
 
 // src/effect/schema.ts
 import { CrustError } from "@crustjs/core";
 import { isSome } from "effect/Option";
-import { isSchema } from "effect/Schema";
+import { encodedSchema, isSchema } from "effect/Schema";
 import { getDescriptionAnnotation } from "effect/SchemaAST";
-function arg(name, schema, options) {
-  if (!name.trim()) {
-    throw new CrustError("DEFINITION", "arg(): name is required and must be a non-empty string");
-  }
-  if (!isSchema(schema)) {
-    throw new CrustError("DEFINITION", `arg("${name}"): schema must be an Effect schema`);
-  }
-  return {
-    kind: "arg",
-    name,
-    schema,
-    variadic: options?.variadic
-  };
-}
-function flag(schema, options) {
-  if (!isSchema(schema)) {
-    throw new CrustError("DEFINITION", "flag(): schema must be an Effect schema");
-  }
-  return {
-    kind: "flag",
-    schema,
-    alias: options?.alias
-  };
-}
-function resolveDescription(schema) {
-  return resolveDescriptionFromAst(schema.ast);
-}
-function resolveDescriptionFromAst(ast) {
-  const seen = new Set;
-  let current = ast;
-  for (;; ) {
-    if (seen.has(current)) {
-      return;
-    }
-    seen.add(current);
-    const annotated = getDescriptionAnnotation(current);
-    if (isSome(annotated) && typeof annotated.value === "string") {
-      return annotated.value;
-    }
-    if (current._tag === "Transformation") {
-      current = current.from;
-      continue;
-    }
-    if (current._tag === "Refinement") {
-      current = current.from;
-      continue;
-    }
-    if (current._tag === "Suspend") {
-      current = current.f();
-      continue;
-    }
-    if (current._tag === "Union") {
-      for (const member of current.types) {
-        if (member._tag === "UndefinedKeyword") {
-          continue;
-        }
-        const desc = resolveDescriptionFromAst(member);
-        if (desc !== undefined) {
-          return desc;
-        }
-      }
-      return;
-    }
-    return;
-  }
-}
 
-// src/effect/definitions.ts
+// src/effect/types.ts
+var EFFECT_SCHEMA = Symbol.for("crustjs.validate.effect");
+
+// src/effect/schema.ts
 function unwrapInputAst(ast) {
   let current = ast;
   const seen = new Set;
@@ -180,18 +104,18 @@ function resolveTupleArrayShape(ast, label) {
     return;
   }
   if (ast.elements.length > 0) {
-    throw new CrustError2("DEFINITION", `${label}: tuple schemas with fixed elements are not supported for CLI parsing. Use Schema.Array(T) for repeatable arguments.`);
+    throw new CrustError("DEFINITION", `${label}: tuple schemas with fixed elements are not supported for CLI parsing. Use Schema.Array(T) for repeatable arguments.`);
   }
   if (ast.rest.length !== 1) {
-    throw new CrustError2("DEFINITION", `${label}: tuple schemas are not supported for CLI parsing. Use scalar schemas or array schemas with a single element type.`);
+    throw new CrustError("DEFINITION", `${label}: tuple schemas are not supported for CLI parsing. Use scalar schemas or array schemas with a single element type.`);
   }
   const rest = ast.rest[0];
   if (!rest) {
-    throw new CrustError2("DEFINITION", `${label}: unable to inspect array element schema`);
+    throw new CrustError("DEFINITION", `${label}: unable to inspect array element schema`);
   }
   const primitive = resolvePrimitiveInputType(rest.type);
   if (!primitive) {
-    throw new CrustError2("DEFINITION", `${label}: array element type must be string, number, or boolean`);
+    throw new CrustError("DEFINITION", `${label}: array element type must be string, number, or boolean`);
   }
   return { type: primitive, multiple: true };
 }
@@ -205,7 +129,7 @@ function resolveInputShape(schema, label) {
   if (primitive) {
     return { type: primitive, multiple: false };
   }
-  throw new CrustError2("DEFINITION", `${label}: unsupported schema type for CLI parsing. Use string, number, boolean, enum/literal, or array of these.`);
+  throw new CrustError("DEFINITION", `${label}: unsupported schema type for CLI parsing. Use string, number, boolean, enum/literal, or array of these.`);
 }
 function acceptsUndefined(ast) {
   const unwrapped = unwrapInputAst(ast);
@@ -220,21 +144,98 @@ function acceptsUndefined(ast) {
 function isOptionalInputSchema(schema) {
   return acceptsUndefined(encodedSchema(schema).ast);
 }
-var effectAdapter = {
-  resolveInputShape,
-  isOptionalInputSchema,
-  resolveDescription,
-  commandLabel: "defineEffectCommand",
-  arrayHint: "Schema.Array(...)"
-};
-function argsToDefinitions(args) {
-  return buildArgDefinitions(args, effectAdapter);
+function resolveDescription(schema) {
+  return resolveDescriptionFromAst(schema.ast);
 }
-function flagsToDefinitions(flags) {
-  return buildFlagDefinitions(flags, effectAdapter);
+function resolveDescriptionFromAst(ast) {
+  const seen = new Set;
+  let current = ast;
+  for (;; ) {
+    if (seen.has(current)) {
+      return;
+    }
+    seen.add(current);
+    const annotated = getDescriptionAnnotation(current);
+    if (isSome(annotated) && typeof annotated.value === "string") {
+      return annotated.value;
+    }
+    if (current._tag === "Transformation") {
+      current = current.from;
+      continue;
+    }
+    if (current._tag === "Refinement") {
+      current = current.from;
+      continue;
+    }
+    if (current._tag === "Suspend") {
+      current = current.f();
+      continue;
+    }
+    if (current._tag === "Union") {
+      for (const member of current.types) {
+        if (member._tag === "UndefinedKeyword") {
+          continue;
+        }
+        const desc = resolveDescriptionFromAst(member);
+        if (desc !== undefined) {
+          return desc;
+        }
+      }
+      return;
+    }
+    return;
+  }
 }
-
-// src/effect/command.ts
+function arg(name, schema, options) {
+  if (!name.trim()) {
+    throw new CrustError("DEFINITION", "arg(): name is required and must be a non-empty string");
+  }
+  if (!isSchema(schema)) {
+    throw new CrustError("DEFINITION", `arg("${name}"): schema must be an Effect schema`);
+  }
+  const shape = resolveInputShape(schema, `arg "${name}"`);
+  const variadic = options?.variadic;
+  if (variadic && shape.multiple) {
+    throw new CrustError("DEFINITION", `arg "${name}": variadic args must use a scalar schema; do not wrap the schema in Schema.Array(...)`);
+  }
+  if (!variadic && shape.multiple) {
+    throw new CrustError("DEFINITION", `arg "${name}": array schema requires { variadic: true }`);
+  }
+  const description = resolveDescription(schema);
+  const required = !isOptionalInputSchema(schema);
+  const def = {
+    name,
+    type: shape.type,
+    ...description !== undefined && { description },
+    variadic,
+    ...required && { required: true },
+    [EFFECT_SCHEMA]: schema
+  };
+  return def;
+}
+function flag(schema, options) {
+  if (!isSchema(schema)) {
+    throw new CrustError("DEFINITION", "flag(): schema must be an Effect schema");
+  }
+  const shape = resolveInputShape(schema, "flag");
+  const required = !isOptionalInputSchema(schema);
+  const description = resolveDescription(schema);
+  const alias = options?.alias === undefined ? undefined : typeof options.alias === "string" ? options.alias : [...options.alias];
+  const def = {
+    type: shape.type,
+    ...shape.multiple && { multiple: true },
+    alias,
+    ...description !== undefined && { description },
+    ...required && { required: true },
+    [EFFECT_SCHEMA]: schema
+  };
+  return def;
+}
+// src/effect/withEffect.ts
+import { either, runSync } from "effect/Effect";
+import * as Either from "effect/Either";
+import * as ParseResult from "effect/ParseResult";
+import { decodeUnknown } from "effect/Schema";
 function validateValue(schema, value, prefix) {
   const result = runSync(either(decodeUnknown(schema)(value)));
   if (Either.isRight(result)) {
@@ -247,28 +248,11 @@ function validateValue(schema, value, prefix) {
   }));
   return { ok: false, issues: normalizeIssues(prefixed) };
 }
-function defineEffectCommand(config) {
-  const {
-    args: effectArgs,
-    flags: effectFlags,
-    run: userRun,
-    ...passthrough
-  } = config;
-  const argSpecs = effectArgs ?? [];
-  const generatedArgs = argsToDefinitions(argSpecs);
-  const generatedFlags = flagsToDefinitions(effectFlags);
-  const command = defineCommand({
-    ...passthrough,
-    ...generatedArgs.length > 0 && { args: generatedArgs },
-    ...Object.keys(generatedFlags).length > 0 && { flags: generatedFlags },
-    ...userRun && {
-      run: buildRunHandler(argSpecs, effectFlags, userRun, validateValue)
-    }
-  });
-  return command;
+function withEffect(handler) {
+  return buildValidatedRunner(handler, validateValue, EFFECT_SCHEMA, "withEffect");
 }
 export {
+  withEffect,
   flag,
-  defineEffectCommand,
   arg
 };

package/dist/shared/chunk-p8pzhj6c.js

@@ -0,0 +1,120 @@
+// @bun
+// src/validation.ts
+import { CrustError } from "@crustjs/core";
+function formatPath(path) {
+  let result = "";
+  for (const segment of path) {
+    if (typeof segment === "number") {
+      result += `[${String(segment)}]`;
+    } else {
+      const str = String(segment);
+      if (result.length > 0) {
+        result += `.${str}`;
+      } else {
+        result = str;
+      }
+    }
+  }
+  return result;
+}
+function normalizeIssue(issue) {
+  return {
+    message: issue.message,
+    path: issue.path ? formatPath(issue.path) : ""
+  };
+}
+function normalizeIssues(issues) {
+  return issues.map(normalizeIssue);
+}
+function renderIssueLine(issue) {
+  if (issue.path) {
+    return `  - ${issue.path}: ${issue.message}`;
+  }
+  return `  - ${issue.message}`;
+}
+function renderBulletList(prefix, issues) {
+  if (issues.length === 0)
+    return prefix;
+  const lines = issues.map(renderIssueLine);
+  return `${prefix}
+${lines.join(`
+`)}`;
+}
+function throwValidationError(issues, prefix = "Validation failed") {
+  const message = renderBulletList(prefix, issues);
+  throw new CrustError("VALIDATION", message, { issues }).withCause(issues);
+}
+
+// src/middleware.ts
+function buildValidatedRunner(userRun, validateValue, schemaKey, label) {
+  return async (context) => {
+    const issues = [];
+    const argDefs = context.command.args ?? [];
+    const validatedArgs = {};
+    for (const def of argDefs) {
+      const schema = def[schemaKey];
+      if (!schema) {
+        validatedArgs[def.name] = context.args[def.name];
+        continue;
+      }
+      const rawValue = context.args[def.name];
+      if (def.variadic) {
+        const items = Array.isArray(rawValue) ? rawValue : rawValue === undefined ? [] : [rawValue];
+        const transformed = [];
+        for (let i = 0;i < items.length; i++) {
+          const value = items[i];
+          const result2 = await validateValue(schema, value, [
+            "args",
+            def.name,
+            i
+          ]);
+          if (!result2.ok) {
+            issues.push(...result2.issues);
+            continue;
+          }
+          transformed.push(result2.value);
+        }
+        validatedArgs[def.name] = transformed;
+        continue;
+      }
+      const result = await validateValue(schema, rawValue, ["args", def.name]);
+      if (!result.ok) {
+        issues.push(...result.issues);
+        continue;
+      }
+      validatedArgs[def.name] = result.value;
+    }
+    const flagDefs = context.command.flags ?? {};
+    const validatedFlags = {};
+    for (const [name, def] of Object.entries(flagDefs)) {
+      const schema = def[schemaKey];
+      if (!schema) {
+        validatedFlags[name] = context.flags[name];
+        continue;
+      }
+      const rawValue = context.flags[name];
+      const result = await validateValue(schema, rawValue, ["flags", name]);
+      if (!result.ok) {
+        issues.push(...result.issues);
+        continue;
+      }
+      validatedFlags[name] = result.value;
+    }
+    if (issues.length > 0) {
+      throwValidationError(issues, `${label}: validation failed`);
+    }
+    const validatedContext = {
+      args: validatedArgs,
+      flags: validatedFlags,
+      rawArgs: context.rawArgs,
+      command: context.command,
+      input: {
+        args: context.args,
+        flags: context.flags
+      }
+    };
+    return userRun(validatedContext);
+  };
+}
+
+export { normalizeIssues, buildValidatedRunner };