@effected/cli 0.25.0 → 0.27.0

package/commands/schema/flags.js

@@ -0,0 +1,24 @@
+import { Argument, Flag } from "effect/cli";
+
+// src/commands/schema/flags.ts
+/** The optional positional config path; omitted, the config is discovered upward from the working directory. */
+const configArgument = Argument.String("config").pipe(Argument.withDescription("Path to a schemastore config module; omitted, schemastore.config.{ts,mts,js,mjs} is searched upward from the working directory"), Argument.optional);
+/** `--format`: absent, JSON for an agent and human text for everyone else. */
+const formatFlag = Flag.Literals("format", ["human", "json"]).pipe(Flag.withDescription("Output format, by default json for an agent and human otherwise; json writes one document to stdout and moves human text to stderr"), Flag.optional);
+/** `--ignore-version-mismatch`: run on past a config from another `@effected/schemastore`. */
+const ignoreVersionMismatchFlag = Flag.Boolean("ignore-version-mismatch").pipe(Flag.withDefault(false), Flag.withDescription("Run even when the config's values come from a different @effected/schemastore than this tool's; warns loudly"));
+/** What `build` and `check` take. */
+const commandFlags = {
+	config: configArgument,
+	drift: Flag.Literals("drift", [
+		"strict",
+		"semantic",
+		"allow"
+	]).pipe(Flag.withDescription("Drift tolerance for published schemas; overrides every schema's drift"), Flag.optional),
+	onDrift: Flag.Literals("on-drift", ["error", "warn"]).pipe(Flag.withDescription("What drift does: refuse every write (error) or write and warn; overrides the config's onDrift"), Flag.optional),
+	force: Flag.Boolean("force").pipe(Flag.withDefault(false), Flag.withDescription("Shorthand for --drift=allow")),
+	format: formatFlag,
+	ignoreVersionMismatch: ignoreVersionMismatchFlag
+};
+
+export { commandFlags, configArgument, formatFlag, ignoreVersionMismatchFlag };

package/commands/schema/index.js

@@ -0,0 +1,14 @@
+import { makeBuildCommand } from "./build.js";
+import { makeCheckCommand } from "./check.js";
+import { makeValidateCommand } from "./validate.js";
+import { Command } from "effect/cli";
+
+// src/commands/schema/index.ts
+/** `effected schema`: the group, closed over the process boundary it runs against. */
+const makeSchemaCommand = (deps) => Command.make("schema", {}).pipe(Command.withDescription("Build and check SchemaStore-shaped JSON Schema documents from a schemastore.config.ts, and validate payloads against them"), Command.withSubcommands([
+	makeBuildCommand(deps),
+	makeCheckCommand(deps),
+	makeValidateCommand(deps)
+]));
+
+export { makeSchemaCommand };

package/commands/schema/validate.js

@@ -0,0 +1,58 @@
+import { ValidationFailedError } from "./errors.js";
+import { configFailures, resolveFormat, warnVersionMismatch } from "./execute.js";
+import { configArgument, formatFlag, ignoreVersionMismatchFlag } from "./flags.js";
+import { CliRuntime, Doc } from "@effected/cli-kit";
+import { Argument, Command, Flag } from "effect/cli";
+import { SchemaValidate, ValidateReport } from "@effected/engine/schema";
+import { Console, Effect, Option, Schema } from "effect";
+
+// src/commands/schema/validate.ts
+const findingLine = (finding) => {
+	const at = finding.location;
+	const where = at !== void 0 ? `${at.file}:${at.line}:${at.column}: ` : "  ";
+	const keyword = finding.keyword !== void 0 ? ` [${finding.keyword}]` : "";
+	return `${where}${finding.path === "" ? "(root)" : finding.path}: ${finding.message}${keyword}`;
+};
+const humanLines = (report) => report.valid ? [`valid ${report.payload} against ${report.source}`] : [...report.findings.map(findingLine), `${report.findings.length} finding(s): ${report.payload} does not conform to ${report.$ref}`];
+/** Run one `validate`. */
+const runValidate = Effect.fn("effected.schema.validate")(function* (input, deps) {
+	const format = yield* resolveFormat(input.format);
+	const report = yield* SchemaValidate.run({
+		payload: input.payload,
+		versionMismatch: input.ignoreVersionMismatch ? "warn" : "fail",
+		...Option.isSome(input.config) ? { config: input.config.value } : {},
+		...Option.isSome(input.schema) ? { schema: input.schema.value } : {}
+	}, {
+		...deps,
+		onProgress: (event) => event._tag === "Started" && event.versionMismatch !== void 0 ? warnVersionMismatch(event.versionMismatch) : Effect.void
+	}).pipe(Effect.catchTags({
+		...configFailures("validate payload.json lib/schemastore.config.ts", input.config),
+		VersionMismatchError: (error) => Effect.fail(CliRuntime.reported(error, 2)),
+		PayloadError: (error) => Effect.fail(CliRuntime.reported(error, 2)),
+		SchemaResolutionError: (error) => Effect.fail(CliRuntime.reported(error, 2)),
+		MissingSchemaRefError: (error) => Effect.fail(CliRuntime.reported(error, 64))
+	}));
+	const lines = humanLines(report);
+	if (format === "json") {
+		yield* Console.log(JSON.stringify(Schema.encodeSync(ValidateReport.Json)(report)));
+		for (const line of lines) yield* Effect.logInfo(line);
+	} else yield* Doc.print([Doc.lines(lines.map((line, index) => Doc.text(line, report.valid ? "success" : index === lines.length - 1 ? "emphasis" : "error")), { wrap: false })]);
+	if (!report.valid) return yield* Effect.fail(CliRuntime.reported(new ValidationFailedError({
+		count: report.findings.length,
+		payload: report.payload,
+		schema: report.$ref
+	}), 1));
+});
+/**
+* `effected schema validate`: check a payload against a published schema document, named by `--schema` or the payload's
+* `$schema`: a file path, or an identity the config derives. No network is involved.
+*/
+const makeValidateCommand = (deps) => Command.make("validate", {
+	payload: Argument.String("payload").pipe(Argument.withDescription("Path to the JSON payload to validate")),
+	schema: Flag.String("schema").pipe(Flag.optional, Flag.withDescription("The document to validate against: a file path, or a $id/url a config schema derives; omitted, the payload's own $schema property")),
+	config: configArgument,
+	format: formatFlag,
+	ignoreVersionMismatch: ignoreVersionMismatchFlag
+}, (input) => runValidate(input, deps)).pipe(Command.withDescription("Validate a JSON payload against a published schema document, resolved by path or by the config's derived $id/url identities"));
+
+export { makeValidateCommand, runValidate };