@effected/schemastore-cli 0.9.1 → 0.10.0

package/ConfigLoader.js

@@ -41,6 +41,14 @@ const describeMalformedTarget = (schemas) => {
 		if (!(record !== void 0 && Schema.isSchema(record.schema) && typeof record.$id === "string" && typeof record.path === "string" && typeof record.published === "boolean")) return `schemas[${index}] is not a SchemaTarget (missing schema/$id/path/published)`;
 	}
 };
+const describeMalformedCatalog = (catalog) => {
+	if (!Array.isArray(catalog)) return "catalog is not an array";
+	for (const [index, entry] of catalog.entries()) {
+		const record = typeof entry === "object" && entry !== null ? entry : void 0;
+		const config = record !== void 0 && typeof record.config === "object" && record.config !== null ? record.config : void 0;
+		if (config === void 0 || typeof config.path !== "string") return `catalog[${index}] is not a catalog entry (missing config.path)`;
+	}
+};
 const describeDuplicatePath = (config) => {
 	const seen = /* @__PURE__ */ new Set();
 	const paths = [...config.schemas.map((target) => target.path), ...config.catalog.map((c) => c.config.path)];
@@ -141,6 +149,11 @@ var ConfigLoader = class ConfigLoader {
 			path: configPath,
 			reason: malformed
 		}));
+		const malformedCatalog = describeMalformedCatalog(exported.catalog);
+		if (malformedCatalog !== void 0) return yield* Effect.fail(new ConfigLoadError({
+			path: configPath,
+			reason: malformedCatalog
+		}));
 		const directory = path.dirname(configPath);
 		const config = yield* ConfigLoader.resolvePaths(exported, directory);
 		const duplicate = describeDuplicatePath(config);

package/README.md

@@ -90,7 +90,7 @@ schemastore check [config] [--drift=strict|semantic|allow] [--on-drift=error|war
 
 - `build` generates every schema, runs the gates (structural lints and ajv strict mode), applies the drift policy, and writes what passes — content-compared, so unchanged files are untouched — along with each catalog entry.
 - `check` is the identical walk with no writes: it reports what `build` would do under the same flags and exits under the same conditions. It is the CI gate, so it also fails (exit `1`) whenever a build would write anything — a committed schema or catalog entry that differs from what the config generates, or is missing, is stale; run `schemastore build` and commit the result.
-- `--drift` and `--on-drift` override the config's `drift` block for one run; `--force` is sugar for `--drift=allow`.
+- `--drift` and `--on-drift` override the config's `drift` block for one run; `--force` is sugar for `--drift=allow` and nothing else — combined with an explicit non-`allow` `--drift` it is a usage error (exit 64), not a precedence question; `--force --drift=allow` is accepted.
 - `--format=json` emits one JSON document on stdout (config path, per-schema outcome, per-catalog-entry outcome, effective drift policy and its source); human text moves to stderr.
 - When `GITHUB_STEP_SUMMARY` is set, both commands append a markdown summary table.
 
@@ -101,7 +101,7 @@ An unpublished schema is never drift: a contract change at a pinned but unpublis
 | code | meaning |
 | ---- | -------------------------------------------------------------------------- |
 | 0 | success, including drift under `onDrift: warn` |
-| 1 | drift under `onDrift: error`, a gate failure, or — for `check` — any document `build` would write |
+| 1 | drift under `onDrift: error` (the error lists one line per drifting schema: `$id`, change, current and next version), a gate failure, or — for `check` — any document `build` would write |
 | 2 | config not found, failed to load, or failed `SchemastoreConfig` validation |
 | 3 | infrastructure failure |
 | 64 | usage error |

package/Report.js

@@ -40,7 +40,15 @@ const tableRow = (columns) => `| ${columns.join(" | ")} |`;
 */
 var Report = class {
 	constructor() {}
-	/** stdout lines. */
+	/**
+	* stdout lines.
+	*
+	* @remarks
+	* The summary's `drift` count is the number of schemas whose VERDICT is
+	* `"drift"`, independent of `written`/`unchanged`: under
+	* `onDrift: "warn"` a drifting schema is written AND counted as drift,
+	* so the four counts need not sum to the schema total.
+	*/
 	static human(report) {
 		const lines = [];
 		for (const schema of report.schemas) lines.push(...schemaLines(schema, report));

package/Runner.js

@@ -1,21 +1,12 @@
-import { Effect, FileSystem, Path, Schema } from "effect";
+import { Effect, FileSystem, Option, Path, Schema } from "effect";
 import { CanonicalJson, CatalogEntry, DriftPolicy, SchemaPipeline, SchemaVersioning } from "@effected/schemastore";
 
 //#region src/Runner.ts
 const pipelineOptions = { contractChanges: "allow" };
 const catalogText = (target) => CanonicalJson.serialize(Schema.encodeSync(CatalogEntry)(target.entry));
-const jsonEqual = (a, b) => {
-	if (a === b) return true;
-	if (Array.isArray(a) || Array.isArray(b)) return Array.isArray(a) && Array.isArray(b) && a.length === b.length && a.every((v, i) => jsonEqual(v, b[i]));
-	if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
-	const left = a;
-	const right = b;
-	const keys = Object.keys(left);
-	return keys.length === Object.keys(right).length && keys.every((k) => Object.hasOwn(right, k) && jsonEqual(left[k], right[k]));
-};
-const sameJson = (existing, text) => {
+const parsesEqual = (existing, text) => {
 	try {
-		return jsonEqual(JSON.parse(existing), JSON.parse(text));
+		return CanonicalJson.equals(JSON.parse(existing), JSON.parse(text));
 	} catch {
 		return false;
 	}
@@ -88,7 +79,8 @@ var Runner = class {
 		for (const entry of config.catalog) {
 			const { name, path: file } = entry.config;
 			const text = yield* catalogText(entry);
-			if ((yield* fs.exists(file)) && sameJson(yield* fs.readFileString(file), text)) catalog.push({
+			const existing = yield* fs.readFileString(file).pipe(Effect.map(Option.some), Effect.catchIf((error) => error.reason._tag === "NotFound", () => Effect.succeed(Option.none())));
+			if (Option.isSome(existing) && parsesEqual(existing.value, text)) catalog.push({
 				name,
 				path: file,
 				outcome: "unchanged"

package/cli/execute.js

@@ -7,15 +7,30 @@ import { Console, Effect, Option, Schema } from "effect";
 import { SchemaFile, SchemaValidator } from "@effected/schemastore";
 
 //#region src/cli/execute.ts
+const DriftedSchema = Schema.Struct({
+	$id: Schema.String,
+	change: Schema.Literals([
+		"none",
+		"created",
+		"annotations",
+		"contract"
+	]),
+	version: Schema.optionalKey(Schema.String),
+	nextVersion: Schema.optionalKey(Schema.String)
+});
 /**
 * A published schema drifted under `onDrift: "error"`, so nothing was
 * written. Exit `1`.
 *
 * @public
 */
-var DriftError = class extends Schema.TaggedError()("DriftError", { count: Schema.Number }) {
+var DriftError = class extends Schema.TaggedError()("DriftError", { drifted: Schema.Array(DriftedSchema) }) {
+	get count() {
+		return this.drifted.length;
+	}
 	get message() {
-		return `${this.count} published schema(s) drifted; nothing was written. Bump the drifting versions in the config, or re-run with --force to write anyway.`;
+		const lines = this.drifted.map((s) => `  ${s.$id}: ${s.change}${s.version !== void 0 ? ` at published ${s.version}` : ""}${s.nextVersion !== void 0 ? ` → suggest ${s.nextVersion}` : ""}`);
+		return `${this.count} published schema(s) drifted; nothing was written.\n${lines.join("\n")}\nBump the drifting versions in the config, or re-run with --force to write anyway.`;
 	}
 };
 /**
@@ -40,6 +55,18 @@ var StaleError = class extends Schema.TaggedError()("StaleError", { count: Schem
 		return `${this.count} document(s) are stale; run \`schemastore build\` and commit the result.`;
 	}
 };
+/**
+* `--force` (shorthand for `--drift=allow`) was combined with an explicit
+* `--drift` that is not `allow`. Contradictory, so refused as a usage
+* error rather than silently resolving to `allow`. Exit `64`.
+*
+* @public
+*/
+var ConflictingFlagsError = class extends Schema.TaggedError()("ConflictingFlagsError", { policy: Schema.String }) {
+	get message() {
+		return `--force conflicts with --drift=${this.policy}: --force means --drift=allow`;
+	}
+};
 const effectiveDrift = (configured, input) => {
 	return {
 		policy: input.force ? "allow" : Option.getOrElse(input.drift, () => configured.policy),
@@ -58,17 +85,21 @@ const emit = Effect.fn("schemastore.emit")(function* (report, format) {
 * Run one `build` or `check`.
 *
 * @remarks
-* Loads the config, applies the flag overrides, runs the shared walk,
-* emits the report in the requested format, appends the step summary, and
-* fails typed — `GateError`, then `DriftError`, then (for `check` only)
-* `StaleError`, each carrying exit `1` — when the report says the run
-* refused to write or, under `check`, that a build would write. `SchemaFile` is built
-* here over the environment's `FileSystem`; the validator is
-* `deps.validator` or the real engine.
+* Before anything is loaded, `--force` combined with an explicit `--drift`
+* other than `allow` short-circuits with `ConflictingFlagsError` at exit
+* `64` — a usage error, not a run outcome. Otherwise loads the config,
+* applies the flag overrides, runs the shared walk, emits the report in the
+* requested format, appends the step summary, and fails typed —
+* `GateError`, then `DriftError`, then (for `check` only) `StaleError`,
+* each carrying exit `1` — when the report says the run refused to write
+* or, under `check`, that a build would write. `SchemaFile` is built here
+* over the environment's `FileSystem`; the validator is `deps.validator` or
+* the real engine.
 *
 * @public
 */
 const execute = Effect.fn("schemastore.execute")(function* (mode, input, deps) {
+	if (input.force && Option.isSome(input.drift) && input.drift.value !== "allow") return yield* Effect.fail(CliRuntime.reported(new ConflictingFlagsError({ policy: input.drift.value }), 64));
 	const loaded = yield* ConfigLoader.load({
 		cwd: deps.cwd,
 		...Option.isSome(input.config) ? { explicit: input.config.value } : {},
@@ -88,8 +119,13 @@ const execute = Effect.fn("schemastore.execute")(function* (mode, input, deps) {
 		return yield* Effect.fail(CliRuntime.reported(new GateError({ count }), 1));
 	}
 	if (report.drifted && drift.onDrift === "error") {
-		const count = report.schemas.filter((schema) => schema.verdict === "drift").length;
-		return yield* Effect.fail(CliRuntime.reported(new DriftError({ count }), 1));
+		const drifted = report.schemas.filter((schema) => schema.verdict === "drift").map((schema) => ({
+			$id: schema.$id,
+			change: schema.change,
+			...schema.version !== void 0 ? { version: schema.version } : {},
+			...schema.nextVersion !== void 0 ? { nextVersion: schema.nextVersion } : {}
+		}));
+		return yield* Effect.fail(CliRuntime.reported(new DriftError({ drifted }), 1));
 	}
 	if (mode === "check") {
 		const count = report.schemas.filter((schema) => schema.outcome === "would-write").length + report.catalog.filter((entry) => entry.outcome === "would-write").length;
@@ -98,4 +134,4 @@ const execute = Effect.fn("schemastore.execute")(function* (mode, input, deps) {
 });
 
 //#endregion
-export { DriftError, GateError, StaleError, execute };
+export { ConflictingFlagsError, DriftError, GateError, StaleError, execute };

package/cli/program.js

@@ -28,7 +28,8 @@ const trimLoadError = Effect.fn("schemastore.trimLoadError")(function* (error) {
 * Fails with the marked error the runtime maps to the exit code:
 * `ShowHelp` is `64` with parse errors and `0` without (help itself was
 * already rendered); `ConfigNotFoundError` / `ConfigLoadError` are `2`;
-* `DriftError` / `GateError` / `StaleError` arrive already marked `1`.
+* `ConflictingFlagsError` arrives already marked `64`; `DriftError` /
+* `GateError` / `StaleError` arrive already marked `1`.
 *
 * @public
 */

package/main.js

@@ -15,7 +15,7 @@ const render = (error) => CliError.isCliError(error) && error._tag === "ShowHelp
 const main = () => {
 	const run = program(process.argv.slice(2), {
 		cwd: process.cwd(),
-		version: "0.9.1"
+		version: "0.10.0"
 	}).pipe(Effect.provide(NodeServices.layer), CliRuntime.reportFailures({
 		exitCode: 3,
 		render

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@effected/schemastore-cli",
-	"version": "0.9.1",
+	"version": "0.10.0",
 	"private": false,
 	"description": "The schemastore command: build and check SchemaStore-shaped JSON Schema documents from a schemastore.config.ts, with a per-schema published flag and a drift policy.",
 	"keywords": [
@@ -36,11 +36,11 @@
 	},
 	"dependencies": {
 		"@effect/platform-node": "4.0.0-rc.115",
-		"@effected/cli": "^0.5.0",
+		"@effected/cli": "^0.5.1",
 		"jiti": "^2.6.0"
 	},
 	"peerDependencies": {
-		"@effected/schemastore": "0.9.1",
+		"@effected/schemastore": "0.10.0",
 		"effect": "4.0.0-rc.115"
 	},
 	"engines": {