@powerlines/schema 0.11.1 → 0.11.2

package/dist/types.d.mts

@@ -1,39 +1,181 @@
 import { Type } from "@powerlines/deepkit/vendor/type";
-import { JsonSchema7Type } from "@stryke/json";
 import { StandardJSONSchemaV1 } from "@standard-schema/spec";
-import { TypeDefinitionParameter } from "@stryke/types/configuration";
+import { JsonSchemaType } from "@stryke/json/types";
+import { TypeDefinition } from "@stryke/types/configuration";
+import { InputObject, Schema as Schema$1 } from "untyped";
 import * as z3 from "zod/v3";
 
 //#region src/types.d.ts
-type SchemaDefinitionVariant = "json-schema" | "standard-schema" | "zod3" | "reflection";
-interface SchemaDefinitionBase {
-  schema: JsonSchema7Type;
-  variant: SchemaDefinitionVariant;
-  input: SchemaDefinitionInput;
-}
-interface SchemaDefinitionJsonSchema extends SchemaDefinitionBase {
-  schema: JsonSchema7Type;
+type UntypedInputObject = InputObject;
+type UntypedSchema = Schema$1;
+/**
+ * The set of numeric `type` strings supported by JSON Type Definition (RFC 8927).
+ */
+type JTDNumberType = "float32" | "float64" | "int8" | "uint8" | "int16" | "uint16" | "int32" | "uint32";
+/**
+ * The set of string `type` strings supported by JSON Type Definition (RFC 8927).
+ */
+type JTDStringType = "string" | "timestamp";
+/**
+ * The set of `type` strings supported by JSON Type Definition (RFC 8927).
+ */
+type JTDType = JTDNumberType | JTDStringType | "boolean";
+interface JsonSchemaLike {
+  type?: string | string[];
+  format?: string;
+  enum?: unknown[];
+  const?: unknown;
+  items?: JsonSchemaLike | JsonSchemaLike[];
+  properties?: Record<string, JsonSchemaLike>;
+  patternProperties?: Record<string, JsonSchemaLike>;
+  additionalProperties?: boolean | JsonSchemaLike;
+  required?: string[];
+  anyOf?: JsonSchemaLike[];
+  oneOf?: JsonSchemaLike[];
+  allOf?: JsonSchemaLike[];
+  $ref?: string;
+  description?: string;
+  title?: string;
+  default?: unknown;
+  examples?: unknown[];
+  minimum?: number;
+  maximum?: number;
+  exclusiveMinimum?: number | boolean;
+  exclusiveMaximum?: number | boolean;
+  nullable?: boolean;
+  definitions?: Record<string, JsonSchemaLike>;
+  $defs?: Record<string, JsonSchemaLike>;
+  discriminator?: {
+    propertyName?: string;
+  } | string;
+  [key: string]: unknown;
+}
+interface SchemaMetadata {
+  /**
+   * A title for the schema, which can be used by documentation tools or other libraries that support this feature to provide a human-readable name or description for the schema. The presence of this property does not affect the validation behavior of the schema itself, but it can provide additional context or information about the schema when used in conjunction with compatible tools.
+   */
+  title?: string;
+  /**
+   * A description for the schema, which can be used by documentation tools or other libraries that support this feature to provide a human-readable explanation or summary of the schema's purpose and usage. The presence of this property does not affect the validation behavior of the schema itself, but it can provide additional context or information about the schema when used in conjunction with compatible tools.
+   */
+  description?: string;
+  /**
+   * A default value for the schema, which can be used by validation libraries or other tools that support this feature. The presence of this property does not affect the validation behavior of the schema itself, but it can provide additional context or information about the expected data when used in conjunction with compatible tools.
+   */
+  default?: unknown;
+  /**
+   * An array of example values that conform to the schema. This property can be used to provide sample data for documentation purposes or to assist developers in understanding the expected structure and content of the data that the schema represents. The presence of this property does not affect the validation behavior of the schema itself, but it can provide additional context or information about the expected data when used in conjunction with compatible tools.
+   */
+  examples?: unknown[];
+  /**
+   * A table name for the schema, which can be used by documentation tools or other libraries that support this feature to provide a human-readable name or description for the schema. The presence of this property does not affect the validation behavior of the schema itself, but it can provide additional context or information about the schema when used in conjunction with compatible tools.
+   */
+  table?: string;
+  /**
+   * An indicator specifying if the field should be marked as hidden or not.
+   */
+  isHidden?: boolean;
+  /**
+   * An indicator specifying if the field should be ignored or not.
+   */
+  isIgnored?: boolean;
+  /**
+   * An indicator specifying if the field is internal or not.
+   *
+   * @internal
+   */
+  isInternal?: boolean;
+  /**
+   * An indicator specifying if the field should only be populated at runtime or not.
+   */
+  isRuntime?: boolean;
+  /**
+   * An indicator specifying if the field is read-only or not. This property can be used to indicate that a field should not be modified after it has been set, which can be useful for documentation purposes or to assist developers in understanding the expected behavior of the data that the schema represents. The presence of this property does not affect the validation behavior of the schema itself, but it can provide additional context or information about the expected data when used in conjunction with compatible tools.
+   */
+  isReadonly?: boolean;
+  /**
+   * An indicator specifying if the field is a primary key or not. This property can be used to indicate that a field serves as a unique identifier for records in a dataset, which can be useful for documentation purposes or to assist developers in understanding the expected structure and behavior of the data that the schema represents. The presence of this property does not affect the validation behavior of the schema itself, but it can provide additional context or information about the expected data when used in conjunction with compatible tools.
+   */
+  isPrimaryKey?: boolean;
+  /**
+   * An array of strings or an alias reference to indicate that the field is an alias for one or more other fields. This property can be used to provide alternative names or references for a field, which can be useful for documentation purposes or to assist developers in understanding the expected structure and content of the data that the schema represents. The presence of this property does not affect the validation behavior of the schema itself, but it can provide additional context or information about the expected data when used in conjunction with compatible tools.
+   */
+  alias?: string[];
+  /**
+   * Schemas that are unioned together to form a single schema. This property can be used to represent complex data structures that can conform to multiple different schemas. The presence of this property does not affect the validation behavior of the schema itself, but it can provide additional context or information about the expected data when used in conjunction with compatible tools.
+   */
+  union?: JsonSchemaLike[];
+  [key: string]: unknown | undefined;
+}
+type JTDSchemaType<TMetadata extends Partial<SchemaMetadata> = Partial<SchemaMetadata>> = ({
+  ref: string;
+} | {
+  type: JTDType;
+} | {
+  enum: string[];
+} | {
+  elements: JTDSchemaType<TMetadata>;
+} | {
+  values: JTDSchemaType<TMetadata>;
+} | {
+  properties: Record<string, JTDSchemaType<TMetadata>>;
+  optionalProperties?: Record<string, JTDSchemaType<TMetadata>>;
+  additionalProperties?: boolean;
+} | {
+  properties?: Record<string, JTDSchemaType<TMetadata>>;
+  optionalProperties: Record<string, JTDSchemaType<TMetadata>>;
+  additionalProperties?: boolean;
+} | {
+  discriminator: string;
+  mapping: Record<string, JTDSchemaType<TMetadata>>;
+} | {}) & {
+  nullable?: boolean;
+  metadata?: TMetadata;
+  definitions?: Record<string, JTDSchemaType<TMetadata>>;
+};
+type SchemaSourceVariant = "standard-schema" | "jtd-schema" | "json-schema" | "zod3" | "untyped" | "reflection";
+type SchemaInputVariant = SchemaSourceVariant | "type-definition";
+type SchemaSourceInput<TMetadata extends Partial<SchemaMetadata> = Partial<SchemaMetadata>> = StandardJSONSchemaV1 | JTDSchemaType<TMetadata> | JsonSchemaType | z3.ZodTypeAny | UntypedInputObject | UntypedSchema | Type;
+type TypeDefinitionReference = TypeDefinition | string;
+type SchemaInput = SchemaSourceInput | Schema | TypeDefinitionReference;
+interface Schema<TMetadata extends Partial<SchemaMetadata> = Partial<SchemaMetadata>> {
+  hash: string;
+  variant: SchemaInputVariant;
+  schema: JTDSchemaType<TMetadata>;
+}
+interface BaseSchemaSource {
+  hash: string;
+  variant: SchemaSourceVariant;
+  schema: SchemaSourceInput;
+}
+interface JTDSchemaSchemaSource<TMetadata extends Partial<SchemaMetadata> = Partial<SchemaMetadata>> extends BaseSchemaSource {
+  variant: "jtd-schema";
+  schema: JTDSchemaType<TMetadata>;
+}
+interface JsonSchemaSchemaSource extends BaseSchemaSource {
   variant: "json-schema";
-  input: JsonSchema7Type;
+  schema: JsonSchemaType;
 }
-interface SchemaDefinitionStandardSchema extends SchemaDefinitionBase {
-  schema: JsonSchema7Type;
+interface StandardSchemaSchemaSource extends BaseSchemaSource {
   variant: "standard-schema";
-  input: StandardJSONSchemaV1;
+  schema: StandardJSONSchemaV1;
 }
-interface SchemaDefinitionZod3 extends SchemaDefinitionBase {
-  schema: JsonSchema7Type;
+interface Zod3SchemaSource extends BaseSchemaSource {
   variant: "zod3";
-  input: z3.ZodTypeAny;
+  schema: z3.ZodTypeAny;
 }
-interface SchemaDefinitionReflection extends SchemaDefinitionBase {
-  schema: JsonSchema7Type;
+interface ReflectionSchemaSource extends BaseSchemaSource {
   variant: "reflection";
-  input: Type;
+  schema: Type;
+}
+interface UntypedSchemaSource extends BaseSchemaSource {
+  variant: "untyped";
+  schema: UntypedInputObject | UntypedSchema;
+}
+type SchemaSource = JsonSchemaSchemaSource | JTDSchemaSchemaSource | StandardSchemaSchemaSource | Zod3SchemaSource | UntypedSchemaSource | ReflectionSchemaSource;
+interface ExtractedSchema<TMetadata extends Partial<SchemaMetadata> = Partial<SchemaMetadata>> extends Schema<TMetadata> {
+  source: SchemaSource;
 }
-type SchemaDefinition = SchemaDefinitionJsonSchema | SchemaDefinitionStandardSchema | SchemaDefinitionZod3 | SchemaDefinitionReflection;
-type SchemaDefinitionInput = SchemaDefinition | JsonSchema7Type | StandardJSONSchemaV1 | z3.ZodTypeAny | Type;
-type SchemaDefinitionParameter = SchemaDefinitionInput | TypeDefinitionParameter;
 //#endregion
-export { SchemaDefinition, SchemaDefinitionBase, SchemaDefinitionInput, SchemaDefinitionJsonSchema, SchemaDefinitionParameter, SchemaDefinitionReflection, SchemaDefinitionStandardSchema, SchemaDefinitionVariant, SchemaDefinitionZod3 };
+export { BaseSchemaSource, ExtractedSchema, JTDNumberType, JTDSchemaSchemaSource, JTDSchemaType, JTDStringType, JTDType, JsonSchemaLike, JsonSchemaSchemaSource, ReflectionSchemaSource, Schema, SchemaInput, SchemaInputVariant, SchemaMetadata, SchemaSource, SchemaSourceInput, SchemaSourceVariant, StandardSchemaSchemaSource, TypeDefinitionReference, UntypedInputObject, UntypedSchema, UntypedSchemaSource, Zod3SchemaSource };
 //# sourceMappingURL=types.d.mts.map

package/dist/types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.mts","names":[],"sources":["../src/types.ts"],"mappings":";;;;;;;KAwBY,uBAAA;AAAA,UAMK,oBAAA;EACf,MAAA,EAAQ,eAAA;EACR,OAAA,EAAS,uBAAA;EACT,KAAA,EAAO,qBAAA;AAAA;AAAA,UAGQ,0BAAA,SAAmC,oBAAA;EAClD,MAAA,EAAQ,eAAA;EACR,OAAA;EACA,KAAA,EAAO,eAAA;AAAA;AAAA,UAGQ,8BAAA,SAAuC,oBAAA;EACtD,MAAA,EAAQ,eAAA;EACR,OAAA;EACA,KAAA,EAAO,oBAAA;AAAA;AAAA,UAGQ,oBAAA,SAA6B,oBAAA;EAC5C,MAAA,EAAQ,eAAA;EACR,OAAA;EACA,KAAA,EAAO,EAAA,CAAG,UAAA;AAAA;AAAA,UAGK,0BAAA,SAAmC,oBAAA;EAClD,MAAA,EAAQ,eAAA;EACR,OAAA;EACA,KAAA,EAAO,IAAA;AAAA;AAAA,KAGG,gBAAA,GACR,0BAAA,GACA,8BAAA,GACA,oBAAA,GACA,0BAAA;AAAA,KAEQ,qBAAA,GACR,gBAAA,GACA,eAAA,GACA,oBAAA,GACA,EAAA,CAAG,UAAA,GACH,IAAA;AAAA,KAEQ,yBAAA,GACR,qBAAA,GACA,uBAAA"}
+{"version":3,"file":"types.d.mts","names":[],"sources":["../src/types.ts"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@powerlines/schema",
-  "version": "0.11.1",
+  "version": "0.11.2",
   "private": false,
   "description": "A package containing a Powerlines plugin to assist in developing other Powerlines plugins.",
   "keywords": [
@@ -54,14 +54,15 @@
       "import": "./dist/bundle.mjs",
       "require": "./dist/bundle.cjs"
     },
+    "./codegen": {
+      "import": "./dist/codegen.mjs",
+      "require": "./dist/codegen.cjs"
+    },
     "./extract": {
       "import": "./dist/extract.mjs",
       "require": "./dist/extract.cjs"
     },
-    "./is-schema-definition": {
-      "import": "./dist/is-schema-definition.mjs",
-      "require": "./dist/is-schema-definition.cjs"
-    },
+    "./jtd": { "import": "./dist/jtd.mjs", "require": "./dist/jtd.cjs" },
     "./reflection": {
       "import": "./dist/reflection.mjs",
       "require": "./dist/reflection.cjs"
@@ -70,6 +71,10 @@
       "import": "./dist/resolve.mjs",
       "require": "./dist/resolve.cjs"
     },
+    "./type-checks": {
+      "import": "./dist/type-checks.mjs",
+      "require": "./dist/type-checks.cjs"
+    },
     "./types": { "import": "./dist/types.mjs", "require": "./dist/types.cjs" },
     "./package.json": "./package.json"
   },
@@ -79,25 +84,26 @@
   "typings": "dist/index.d.mts",
   "files": ["dist"],
   "dependencies": {
-    "@powerlines/core": "^0.15.1",
-    "@powerlines/deepkit": "^0.8.66",
-    "@powerlines/unplugin": "^0.0.11",
+    "@powerlines/core": "^0.11.2",
+    "@powerlines/deepkit": "^0.11.2",
+    "@powerlines/unplugin": "^0.0.15",
     "@standard-schema/spec": "^1.1.0",
-    "@standard-schema/utils": "^0.3.0",
-    "@stryke/fs": "^0.33.75",
-    "@stryke/helpers": "^0.10.15",
-    "@stryke/json": "^0.14.20",
-    "@stryke/path": "^0.29.2",
-    "@stryke/type-checks": "^0.6.8",
-    "@stryke/types": "^0.12.3",
-    "@stryke/zod": "^0.3.21",
+    "@stryke/hash": "^0.13.29",
+    "@stryke/helpers": "^0.10.16",
+    "@stryke/json": "^0.15.0",
+    "@stryke/path": "^0.29.3",
+    "@stryke/type-checks": "^0.6.9",
+    "@stryke/types": "^0.12.4",
+    "@stryke/zod": "^0.3.22",
+    "ajv": "^8.20.0",
     "defu": "^6.1.7",
     "esbuild": "^0.27.7",
-    "typescript": "^6.0.3"
+    "typescript": "^6.0.3",
+    "untyped": "^1.5.2"
   },
-  "devDependencies": { "zod": "^4.4.3", "@types/node": "^25.7.0" },
+  "devDependencies": { "@types/node": "^25.8.0", "zod": "^4.4.3" },
   "peerDependencies": { "zod": "^3.25.0 || ^4.0.0" },
   "peerDependenciesMeta": { "zod": { "optional": true } },
   "publishConfig": { "access": "public" },
-  "gitHead": "0baea9ad9bcd4d8a4eeeed56cac8ba739ca529c1"
+  "gitHead": "36f51f76091249b5d769528d78908d4aa72705de"
 }

package/dist/is-schema-definition.cjs

@@ -1,18 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_runtime = require('./_virtual/_rolldown/runtime.cjs');
-let _stryke_type_checks = require("@stryke/type-checks");
-let _stryke_json_schema = require("@stryke/json/schema");
-
-//#region src/is-schema-definition.ts
-/**
-* Type guard to check if a given input is a `SchemaDefinition` object. This function verifies that the input is a non-null object, contains a `schema` property that is a JSON Schema (draft-07) object, contains an `input` property that is a non-null object, and has a `variant` property that is one of the allowed schema variants ("json-schema", "standard-schema", "zod3", or "reflection"). If all these conditions are met, the function returns `true`, indicating that the input is a valid `SchemaDefinition`; otherwise, it returns `false`.
-*
-* @param input - The input to check for being a `SchemaDefinition`.
-* @returns `true` if the input is a `SchemaDefinition`, otherwise `false`.
-*/
-function isSchemaDefinition(input) {
-	return (0, _stryke_type_checks.isSetObject)(input) && "schema" in input && (0, _stryke_json_schema.isJsonSchema7ObjectType)(input.schema) && "input" in input && (0, _stryke_type_checks.isSetObject)(input.input) && "variant" in input && (input.variant === "json-schema" || input.variant === "standard-schema" || input.variant === "zod3" || input.variant === "reflection");
-}
-
-//#endregion
-exports.isSchemaDefinition = isSchemaDefinition;

package/dist/is-schema-definition.d.cts

@@ -1,13 +0,0 @@
-import { SchemaDefinition } from "./types.cjs";
-
-//#region src/is-schema-definition.d.ts
-/**
- * Type guard to check if a given input is a `SchemaDefinition` object. This function verifies that the input is a non-null object, contains a `schema` property that is a JSON Schema (draft-07) object, contains an `input` property that is a non-null object, and has a `variant` property that is one of the allowed schema variants ("json-schema", "standard-schema", "zod3", or "reflection"). If all these conditions are met, the function returns `true`, indicating that the input is a valid `SchemaDefinition`; otherwise, it returns `false`.
- *
- * @param input - The input to check for being a `SchemaDefinition`.
- * @returns `true` if the input is a `SchemaDefinition`, otherwise `false`.
- */
-declare function isSchemaDefinition(input: unknown): input is SchemaDefinition;
-//#endregion
-export { isSchemaDefinition };
-//# sourceMappingURL=is-schema-definition.d.cts.map

package/dist/is-schema-definition.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"is-schema-definition.d.cts","names":[],"sources":["../src/is-schema-definition.ts"],"mappings":";;;;;AA4BA;;;;iBAAgB,kBAAA,CAAmB,KAAA,YAAiB,KAAA,IAAS,gBAAA"}

package/dist/is-schema-definition.d.mts

@@ -1,13 +0,0 @@
-import { SchemaDefinition } from "./types.mjs";
-
-//#region src/is-schema-definition.d.ts
-/**
- * Type guard to check if a given input is a `SchemaDefinition` object. This function verifies that the input is a non-null object, contains a `schema` property that is a JSON Schema (draft-07) object, contains an `input` property that is a non-null object, and has a `variant` property that is one of the allowed schema variants ("json-schema", "standard-schema", "zod3", or "reflection"). If all these conditions are met, the function returns `true`, indicating that the input is a valid `SchemaDefinition`; otherwise, it returns `false`.
- *
- * @param input - The input to check for being a `SchemaDefinition`.
- * @returns `true` if the input is a `SchemaDefinition`, otherwise `false`.
- */
-declare function isSchemaDefinition(input: unknown): input is SchemaDefinition;
-//#endregion
-export { isSchemaDefinition };
-//# sourceMappingURL=is-schema-definition.d.mts.map

package/dist/is-schema-definition.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"is-schema-definition.d.mts","names":[],"sources":["../src/is-schema-definition.ts"],"mappings":";;;;;AA4BA;;;;iBAAgB,kBAAA,CAAmB,KAAA,YAAiB,KAAA,IAAS,gBAAA"}

package/dist/is-schema-definition.mjs

@@ -1,17 +0,0 @@
-import { isSetObject } from "@stryke/type-checks";
-import { isJsonSchema7ObjectType } from "@stryke/json/schema";
-
-//#region src/is-schema-definition.ts
-/**
-* Type guard to check if a given input is a `SchemaDefinition` object. This function verifies that the input is a non-null object, contains a `schema` property that is a JSON Schema (draft-07) object, contains an `input` property that is a non-null object, and has a `variant` property that is one of the allowed schema variants ("json-schema", "standard-schema", "zod3", or "reflection"). If all these conditions are met, the function returns `true`, indicating that the input is a valid `SchemaDefinition`; otherwise, it returns `false`.
-*
-* @param input - The input to check for being a `SchemaDefinition`.
-* @returns `true` if the input is a `SchemaDefinition`, otherwise `false`.
-*/
-function isSchemaDefinition(input) {
-	return isSetObject(input) && "schema" in input && isJsonSchema7ObjectType(input.schema) && "input" in input && isSetObject(input.input) && "variant" in input && (input.variant === "json-schema" || input.variant === "standard-schema" || input.variant === "zod3" || input.variant === "reflection");
-}
-
-//#endregion
-export { isSchemaDefinition };
-//# sourceMappingURL=is-schema-definition.mjs.map

package/dist/is-schema-definition.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"is-schema-definition.mjs","names":[],"sources":["../src/is-schema-definition.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                   ⚡ Storm Software - Powerlines\n\n This code was released as part of the Powerlines project. Powerlines\n is maintained by Storm Software under the Apache-2.0 license, and is\n free for commercial and private use. For more information, please visit\n our licensing page at https://stormsoftware.com/licenses/projects/powerlines.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software/powerlines\n Documentation:            https://docs.stormsoftware.com/projects/powerlines\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\nimport { isJsonSchema7ObjectType } from \"@stryke/json/schema\";\nimport { isSetObject } from \"@stryke/type-checks\";\nimport { SchemaDefinition } from \"./types\";\n\n/**\n * Type guard to check if a given input is a `SchemaDefinition` object. This function verifies that the input is a non-null object, contains a `schema` property that is a JSON Schema (draft-07) object, contains an `input` property that is a non-null object, and has a `variant` property that is one of the allowed schema variants (\"json-schema\", \"standard-schema\", \"zod3\", or \"reflection\"). If all these conditions are met, the function returns `true`, indicating that the input is a valid `SchemaDefinition`; otherwise, it returns `false`.\n *\n * @param input - The input to check for being a `SchemaDefinition`.\n * @returns `true` if the input is a `SchemaDefinition`, otherwise `false`.\n */\nexport function isSchemaDefinition(input: unknown): input is SchemaDefinition {\n  return (\n    isSetObject(input) &&\n    \"schema\" in input &&\n    isJsonSchema7ObjectType(input.schema) &&\n    \"input\" in input &&\n    isSetObject(input.input) &&\n    \"variant\" in input &&\n    (input.variant === \"json-schema\" ||\n      input.variant === \"standard-schema\" ||\n      input.variant === \"zod3\" ||\n      input.variant === \"reflection\")\n  );\n}\n"],"mappings":";;;;;;;;;;AA4BA,SAAgB,mBAAmB,OAA2C;AAC5E,QACE,YAAY,MAAM,IAClB,YAAY,SACZ,wBAAwB,MAAM,OAAO,IACrC,WAAW,SACX,YAAY,MAAM,MAAM,IACxB,aAAa,UACZ,MAAM,YAAY,iBACjB,MAAM,YAAY,qBAClB,MAAM,YAAY,UAClB,MAAM,YAAY"}