@effected/schemastore 0.7.0 → 0.8.0

package/README.md

@@ -71,10 +71,12 @@ console.log(Effect.runSync(program));
 //   "required": [
 //     "name"
 //   ],
-//   "additionalProperties": false
+//   "additionalProperties": true
 // }
 ```
 
+`additionalProperties: true` is core's default for a struct: `Schema.toJsonSchemaDocument` emits open objects unless told otherwise. A config schema usually wants the closed form, and `jsonSchema: { onExcessProperty: "error" }` in the options produces it; the same option lives on a pipeline target, below.
+
 `fromSchema` runs the whole pipeline — 2020-12 generation, Draft-07 lowering, the `$ref` rewrite and the declared-family gate — so every `$ref` in a built document already resolves against its `$defs` pool. `toJson()` is the flat publication shape (`$defs` omitted when empty) and `serializeResult` routes through the owned canonical serializer, tab-indented with a single trailing newline. If core cannot convert a schema, the failure is typed as `SchemaConversionError` and carries the `$id` and the structured cause.
 
 ## Annotate at the definition site
@@ -243,6 +245,7 @@ const targets = [
     schema: Schema.Struct({ name: Schema.String }),
     $id: "https://example.com/config.schema.json",
     path: "schemas/config.schema.json",
+    jsonSchema: { onExcessProperty: "error" },
   }),
 ];
 
@@ -268,6 +271,8 @@ provide the same value cannot disagree about what the layer contains.
 
 A target names its schema, its `$id` and where the file goes. `name` is optional and only catalog naming reads it, so a file-only target like the one above does not repeat its path's basename; supply it when you also pass a `version`, since versioned naming is `<name>-<version>.json`.
 
+`jsonSchema` is optional too, and carries core's `Schema.ToJsonSchemaOptions` for that one target. Set it when the document's shape must not follow core's defaults: `onExcessProperty: "error"` keeps a published closed-object document closed, where the open-by-default generator would otherwise flip every struct's `additionalProperties` and the contract gate would refuse the rewrite. Living on the target rather than in the pipeline options keeps each document's generation contract self-describing.
+
 Both gates' findings normalize into one `PipelineFinding` shape, so a single predicate judges them. Gating is **policy, not mechanism**: `blocking` defaults to `severity === "warning"`, which is what `UnresolvedRef`, `UnknownKeyword` and `DepthExceeded` are. Replace the predicate rather than the loop when you disagree.
 
 ```ts
@@ -326,7 +331,7 @@ The classification is key-order insensitive and keyword-position aware, like the
 - `DocumentDiff` — `classify` puts two documents in `"none"` / `"annotations"` / `"contract"`, the signal for whether a change needs a new schema version, plus `isClean` for the clean case.
 - `SchemaPipeline` — the emit loop over a target manifest, two-phase and all-or-nothing across targets: `run` and `check`, the single-target `runOne` and `checkOne`, `PipelineFinding`, `SchemaGateError` and an overridable gating predicate, plus the contract gate (`ContractChangePolicy`, `ContractChangeTarget`, `SchemaContractChangeError`, `PipelineCheckResult.contractBlocked`) that refuses to rewrite a published document's validation contract in place.
 - `SchemaFile` — write-if-changed IO over core `FileSystem` / `Path`, comparing by content and answering what changed as a value; `check` is the non-writing drift half, answering `wouldWrite` alongside `change`.
-- `SchemaTarget` — the target manifest vocabulary: schema, `$id`, destination path, an optional name and an optional version that requires one.
+- `SchemaTarget` — the target manifest vocabulary: schema, `$id`, destination path, an optional name, an optional version that requires one, and optional per-target `jsonSchema` generation options.
 - `CanonicalJson` — the deterministic serializer with typed failures (`NonJsonValueError`, `JsonDepthExceededError`).
 
 ## License

package/SchemaPipeline.js

@@ -195,7 +195,10 @@ var SchemaPipeline = class SchemaPipeline {
 			const held = [];
 			const blocked = [];
 			for (const target of targets) {
-				const document = yield* StoreDocument.fromSchema(target.schema, { $id: target.$id });
+				const document = yield* StoreDocument.fromSchema(target.schema, {
+					$id: target.$id,
+					...target.jsonSchema !== void 0 ? { jsonSchema: target.jsonSchema } : {}
+				});
 				const findings = yield* gather(document, options);
 				yield* gate(target, findings, options);
 				const version = target.version;
@@ -248,7 +251,10 @@ var SchemaPipeline = class SchemaPipeline {
 			const files = yield* SchemaFile;
 			const results = [];
 			for (const target of targets) {
-				const document = yield* StoreDocument.fromSchema(target.schema, { $id: target.$id });
+				const document = yield* StoreDocument.fromSchema(target.schema, {
+					$id: target.$id,
+					...target.jsonSchema !== void 0 ? { jsonSchema: target.jsonSchema } : {}
+				});
 				const findings = yield* gather(document, options);
 				const { wouldWrite, change } = yield* files.check(target.path, document, options?.write);
 				results.push({

package/SchemaTarget.js

@@ -21,7 +21,8 @@ var SchemaTarget = class {
 			$id: options.$id,
 			path: options.path,
 			...options.name !== void 0 ? { name: options.name } : {},
-			...options.version !== void 0 ? { version: options.version } : {}
+			...options.version !== void 0 ? { version: options.version } : {},
+			...options.jsonSchema !== void 0 ? { jsonSchema: options.jsonSchema } : {}
 		};
 	}
 };

package/index.d.ts

@@ -969,6 +969,19 @@ export interface SchemaTarget {
    * rewritten in place.
    */
   readonly version?: SchemaVersion;
+  /**
+   * Options passed through to {@link StoreDocument.fromSchema} (and, from
+   * there, core's `Schema.toJsonSchemaDocument`).
+   *
+   * A target-level field rather than a pipeline-wide default keeps each
+   * document's generation contract self-describing, so
+   * {@link SchemaPipeline} reproduces a document deterministically
+   * regardless of core's own default — for example, an `onExcessProperty`
+   * setting of `error` restores closed objects after rc.113 flipped that
+   * default open. See {@link StoreDocumentOptions.jsonSchema} for the
+   * `includeAnnotationKey` gate this option is also subject to.
+   */
+  readonly jsonSchema?: Schema.ToJsonSchemaOptions;
 }
 /**
  * Constructors for `SchemaTarget` values.
@@ -986,6 +999,7 @@ export declare class SchemaTarget {
     readonly $id: string;
     readonly name?: string;
     readonly path: string;
+    readonly jsonSchema?: Schema.ToJsonSchemaOptions;
   }): SchemaTarget;
   /**
    * Builds a versioned target. `name` is **required** here: versioned
@@ -999,6 +1013,7 @@ export declare class SchemaTarget {
     readonly name: string;
     readonly path: string;
     readonly version: SchemaVersion;
+    readonly jsonSchema?: Schema.ToJsonSchemaOptions;
   }): SchemaTarget;
 }
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@effected/schemastore",
-	"version": "0.7.0",
+	"version": "0.8.0",
 	"private": false,
 	"description": "Build, validate, version and publish SchemaStore-shaped Draft-07 JSON Schema documents from Effect Schema sources: document assembly, ajv strict-mode validation, structural lints, catalog entries, canonical JSON and a content-comparing emit pipeline.",
 	"keywords": [