@routier/core 0.2.0 → 0.2.1

package/dist/schema/property/base/SchemaBase.d.ts

@@ -1,4 +1,4 @@
-import { DefaultValue, FunctionBody, PropertyDeserializer, PropertySerializer, SchemaModifiers, SchemaTypes } from "../../types";
+import { DefaultValue, ForeignKey, FunctionBody, PropertyDeserializer, PropertySerializer, SchemaModifiers, SchemaTypes } from "../../types";
 export declare abstract class SchemaBase<T extends any, TModifiers extends SchemaModifiers> {
     abstract instance: T;
     modifiers: TModifiers;
@@ -11,6 +11,8 @@ export declare abstract class SchemaBase<T extends any, TModifiers extends Schem
     isDistict: boolean;
     indexes: string[];
     fromPropertyName: string | null;
+    foreignKeyDefinition: ForeignKey<unknown> | null;
+    tags: string[];
     injected: any;
     defaultValue: DefaultValue<T> | null;
     valueSerializer: PropertySerializer<T> | null;

package/dist/schema/property/modifiers/SchemaDeserialize.d.ts

@@ -1,6 +1,8 @@
-import { PropertyDeserializer, PropertySerializer, SchemaModifiers } from "../../types";
+import { DefaultValue, PropertyDeserializer, PropertySerializer, SchemaModifiers } from "../../types";
 import { SchemaBase } from "../base/SchemaBase";
+import { SchemaDefault } from "./SchemaDefault";
 import { SchemaFrom } from "./SchemaFrom";
+import { SchemaOptional } from "./SchemaOptional";
 import { SchemaSerialize } from "./SchemaSerialize";
 export declare class SchemaDeserialize<T extends any, TModifiers extends SchemaModifiers> extends SchemaBase<T, TModifiers> {
     instance: T;
@@ -8,4 +10,6 @@ export declare class SchemaDeserialize<T extends any, TModifiers extends SchemaM
     constructor(deserializer: PropertyDeserializer<T>, current: SchemaBase<T, TModifiers>);
     serialize(serializer: PropertySerializer<T>): SchemaSerialize<T, "serialize" | TModifiers>;
     from(propertyName: string): SchemaFrom<T, TModifiers>;
+    optional(): SchemaOptional<T, "optional" | TModifiers>;
+    default<I = never>(value: DefaultValue<T | null, I>, injected?: I): SchemaDefault<T, I, "default" | TModifiers>;
 }

package/dist/schema/property/modifiers/SchemaForeignKey.d.ts

@@ -0,0 +1,15 @@
+import { SchemaBase } from "../base/SchemaBase";
+import { SchemaIdentity } from "./SchemaIdentity";
+import { SchemaDefault } from "./SchemaDefault";
+import { CompiledSchema, DefaultValue, InferType, SchemaModifiers } from "../../types";
+import { SchemaFrom } from "./SchemaFrom";
+import { SchemaTag } from "./SchemaTag";
+export declare class SchemaForeignKey<T extends any, TModifiers extends SchemaModifiers, K extends {}> extends SchemaBase<T, TModifiers> {
+    instance: T;
+    private _schemaForeignKey;
+    constructor(current: SchemaBase<T, TModifiers>, relatingSchema: CompiledSchema<K>, property: keyof InferType<CompiledSchema<K>>);
+    identity(): SchemaIdentity<T, "identity" | TModifiers>;
+    default<I = never>(value: DefaultValue<T, I>, injected?: I): SchemaDefault<T, I, "default" | TModifiers>;
+    from(propertyName: string): SchemaFrom<T, TModifiers>;
+    tag(...tags: string[]): SchemaTag<T, TModifiers>;
+}

package/dist/schema/property/modifiers/SchemaKey.d.ts

@@ -3,6 +3,7 @@ import { SchemaIdentity } from "./SchemaIdentity";
 import { SchemaDefault } from "./SchemaDefault";
 import { DefaultValue, IdType, SchemaModifiers } from "../../types";
 import { SchemaFrom } from "./SchemaFrom";
+import { SchemaTag } from "./SchemaTag";
 export declare class SchemaKey<T extends IdType, TModifiers extends SchemaModifiers> extends SchemaBase<T, TModifiers> {
     instance: T;
     private _schemaKey;
@@ -10,4 +11,5 @@ export declare class SchemaKey<T extends IdType, TModifiers extends SchemaModifi
     identity(): SchemaIdentity<T, "identity" | TModifiers>;
     default<I = never>(value: DefaultValue<T, I>, injected?: I): SchemaDefault<T, I, "default" | TModifiers>;
     from(propertyName: string): SchemaFrom<T, TModifiers>;
+    tag(...tags: string[]): SchemaTag<T, TModifiers>;
 }

package/dist/schema/property/modifiers/SchemaNullable.d.ts

@@ -1,9 +1,13 @@
-import { SchemaModifiers } from "../../types";
+import { DefaultValue, PropertyDeserializer, SchemaModifiers } from "../../types";
 import { SchemaBase } from "../base/SchemaBase";
+import { SchemaDefault } from "./SchemaDefault";
+import { SchemaDeserialize } from "./SchemaDeserialize";
 import { SchemaOptional } from "./SchemaOptional";
 export declare class SchemaNullable<T extends any, TModifiers extends SchemaModifiers> extends SchemaBase<T, TModifiers> {
     instance: T;
     private _schemaNullable;
     constructor(current: SchemaBase<T, TModifiers>);
     optional(): SchemaOptional<T, "optional" | TModifiers>;
+    default<I = never>(value: DefaultValue<T | null, I>, injected?: I): SchemaDefault<T, I, "default" | TModifiers>;
+    deserialize(deserializer: PropertyDeserializer<T | null>): SchemaDeserialize<T, "deserialize" | TModifiers>;
 }

package/dist/schema/property/modifiers/SchemaOptional.d.ts

@@ -1,9 +1,11 @@
-import { SchemaModifiers } from "../../types";
+import { PropertyDeserializer, SchemaModifiers } from "../../types";
 import { SchemaBase } from "../base/SchemaBase";
+import { SchemaDeserialize } from "./SchemaDeserialize";
 import { SchemaNullable } from "./SchemaNullable";
 export declare class SchemaOptional<T extends any, TModifiers extends SchemaModifiers> extends SchemaBase<T, TModifiers> {
     instance: T;
     private _schemaOptional;
     constructor(current: SchemaBase<T, TModifiers>);
     nullable(): SchemaNullable<T, "nullable" | TModifiers>;
+    deserialize(deserializer: PropertyDeserializer<T | undefined>): SchemaDeserialize<T, "deserialize" | TModifiers>;
 }

package/dist/schema/property/modifiers/SchemaTag.d.ts

@@ -0,0 +1,27 @@
+import { DefaultValue, PropertyDeserializer, PropertySerializer, SchemaModifiers } from "../../types";
+import { SchemaBase } from "../base/SchemaBase";
+import { SchemaArray } from "../types";
+import { SchemaDefault } from "./SchemaDefault";
+import { SchemaDeserialize } from "./SchemaDeserialize";
+import { SchemaDistinct } from "./SchemaDistinct";
+import { SchemaFrom } from "./SchemaFrom";
+import { SchemaIndex } from "./SchemaIndex";
+import { SchemaNullable } from "./SchemaNullable";
+import { SchemaOptional } from "./SchemaOptional";
+import { SchemaReadonly } from "./SchemaReadonly";
+import { SchemaSerialize } from "./SchemaSerialize";
+export declare class SchemaTag<T extends any, TModifiers extends SchemaModifiers> extends SchemaBase<T, TModifiers> {
+    instance: T;
+    private _schemaTag;
+    constructor(tags: string[], current: SchemaBase<T, TModifiers>);
+    from(propertyName: string): SchemaFrom<T, TModifiers>;
+    optional(): SchemaOptional<T, "optional" | TModifiers>;
+    nullable(): SchemaNullable<T, "nullable" | TModifiers>;
+    default<I = never>(value: DefaultValue<T, I>, injected?: I): SchemaDefault<T, I, "default" | TModifiers>;
+    readonly(): SchemaReadonly<T, "readonly" | TModifiers>;
+    deserialize(deserializer: PropertyDeserializer<T>): SchemaDeserialize<T, "deserialize" | TModifiers>;
+    serialize(serializer: PropertySerializer<T>): SchemaSerialize<T, "serialize" | TModifiers>;
+    array(): SchemaArray<this, TModifiers>;
+    index(...indexes: string[]): SchemaIndex<T, TModifiers>;
+    distinct(): SchemaDistinct<T, "distinct" | TModifiers>;
+}

package/dist/schema/property/modifiers/SchemaTracked.d.ts

@@ -1,9 +1,13 @@
-import { IdType, SchemaModifiers } from "../../types";
+import { CompiledSchema, IdType, InferType, SchemaModifiers } from "../../types";
 import { SchemaBase } from "../base/SchemaBase";
+import { SchemaForeignKey } from "./SchemaForeignKey";
 import { SchemaKey } from "./SchemaKey";
+import { SchemaTag } from "./SchemaTag";
 export declare class SchemaTracked<T extends any, TModifiers extends SchemaModifiers> extends SchemaBase<T, TModifiers> {
     instance: T;
     private _schemaTracked;
     constructor(current: SchemaBase<T, TModifiers>);
     key(): T extends IdType ? SchemaKey<T, TModifiers | "key"> : never;
+    foreignKey<K extends {}>(relatingSchema: CompiledSchema<K>, property: keyof InferType<CompiledSchema<K>>): SchemaForeignKey<T, TModifiers, K>;
+    tag(...tags: string[]): SchemaTag<T, TModifiers>;
 }

package/dist/schema/property/modifiers/index.d.ts

@@ -10,3 +10,5 @@ export * from './SchemaReadonly';
 export * from './SchemaSerialize';
 export * from './SchemaTracked';
 export * from './SchemaFrom';
+export * from './SchemaTag';
+export * from './SchemaForeignKey';

package/dist/schema/property/types/SchemaArray.d.ts

@@ -7,6 +7,7 @@ import { SchemaSerialize } from '../modifiers/SchemaSerialize';
 import { SchemaIndex } from "../modifiers/SchemaIndex";
 import { DefaultValue, PropertyDeserializer, PropertySerializer, SchemaModifiers, SchemaTypes } from "../../types";
 import { SchemaFrom } from "../modifiers/SchemaFrom";
+import { SchemaTag } from "../modifiers/SchemaTag";
 export declare class SchemaArray<T extends any, TModifiers extends SchemaModifiers> extends SchemaBase<T[], TModifiers> {
     instance: T[];
     type: SchemaTypes;
@@ -20,4 +21,5 @@ export declare class SchemaArray<T extends any, TModifiers extends SchemaModifie
     deserialize(deserializer: PropertyDeserializer<T[]>): SchemaDeserialize<T[], "deserialize" | TModifiers>;
     serialize(serializer: PropertySerializer<T[]>): SchemaSerialize<T[], "serialize" | TModifiers>;
     index(...indexes: string[]): SchemaIndex<T[], TModifiers>;
+    tag(...tags: string[]): SchemaTag<T[], TModifiers>;
 }

package/dist/schema/property/types/SchemaBoolean.d.ts

@@ -9,6 +9,7 @@ import { SchemaNullable } from "../modifiers/SchemaNullable";
 import { SchemaOptional } from "../modifiers/SchemaOptional";
 import { SchemaReadonly } from "../modifiers/SchemaReadonly";
 import { SchemaSerialize } from "../modifiers/SchemaSerialize";
+import { SchemaTag } from "../modifiers/SchemaTag";
 import { SchemaArray } from "./SchemaArray";
 export declare class SchemaBoolean<T extends boolean, TModifiers extends SchemaModifiers> extends SchemaBase<T, TModifiers> {
     instance: T;
@@ -24,4 +25,5 @@ export declare class SchemaBoolean<T extends boolean, TModifiers extends SchemaM
     array(): SchemaArray<this, TModifiers>;
     index(...indexes: string[]): SchemaIndex<T, TModifiers>;
     distinct(): SchemaDistinct<T, "distinct" | TModifiers>;
+    tag(...tags: string[]): SchemaTag<T, TModifiers>;
 }

package/dist/schema/property/types/SchemaDate.d.ts

@@ -9,6 +9,7 @@ import { SchemaNullable } from "../modifiers/SchemaNullable";
 import { SchemaOptional } from "../modifiers/SchemaOptional";
 import { SchemaReadonly } from "../modifiers/SchemaReadonly";
 import { SchemaSerialize } from "../modifiers/SchemaSerialize";
+import { SchemaTag } from "../modifiers/SchemaTag";
 import { SchemaArray } from "./SchemaArray";
 export declare class SchemaDate<T extends Date, TModifiers extends SchemaModifiers> extends SchemaBase<T, TModifiers> {
     instance: T;
@@ -24,4 +25,5 @@ export declare class SchemaDate<T extends Date, TModifiers extends SchemaModifie
     array(): SchemaArray<this, TModifiers>;
     index(...indexes: string[]): SchemaIndex<T, TModifiers>;
     distinct(): SchemaDistinct<T, "distinct" | TModifiers>;
+    tag(...tags: string[]): SchemaTag<T, TModifiers>;
 }

package/dist/schema/property/types/SchemaNumber.d.ts

@@ -1,8 +1,9 @@
-import { DefaultValue, PropertyDeserializer, PropertySerializer, SchemaModifiers, SchemaTypes } from "../../types";
+import { CompiledSchema, DefaultValue, InferType, PropertyDeserializer, PropertySerializer, SchemaModifiers, SchemaTypes } from "../../types";
 import { SchemaBase } from "../base/SchemaBase";
 import { SchemaDefault } from "../modifiers/SchemaDefault";
 import { SchemaDeserialize } from "../modifiers/SchemaDeserialize";
 import { SchemaDistinct } from "../modifiers/SchemaDistinct";
+import { SchemaForeignKey } from "../modifiers/SchemaForeignKey";
 import { SchemaFrom } from "../modifiers/SchemaFrom";
 import { SchemaIdentity } from "../modifiers/SchemaIdentity";
 import { SchemaIndex } from "../modifiers/SchemaIndex";
@@ -11,6 +12,7 @@ import { SchemaNullable } from "../modifiers/SchemaNullable";
 import { SchemaOptional } from "../modifiers/SchemaOptional";
 import { SchemaReadonly } from "../modifiers/SchemaReadonly";
 import { SchemaSerialize } from "../modifiers/SchemaSerialize";
+import { SchemaTag } from "../modifiers/SchemaTag";
 import { SchemaArray } from "./SchemaArray";
 export declare class SchemaNumber<T extends number, TModifiers extends SchemaModifiers> extends SchemaBase<T, TModifiers> {
     instance: T;
@@ -21,6 +23,7 @@ export declare class SchemaNumber<T extends number, TModifiers extends SchemaMod
     optional(): SchemaOptional<T, "optional" | TModifiers>;
     nullable(): SchemaNullable<T, "nullable" | TModifiers>;
     key(): SchemaKey<T, "key" | TModifiers>;
+    foreignKey<K extends {}>(relatingSchema: CompiledSchema<K>, property: keyof InferType<CompiledSchema<K>>): SchemaForeignKey<T, TModifiers, K>;
     default<I = never>(value: DefaultValue<T, I>, injected?: I): SchemaDefault<T, I, "default" | TModifiers>;
     readonly(): SchemaReadonly<T, "readonly" | TModifiers>;
     deserialize(deserializer: PropertyDeserializer<T>): SchemaDeserialize<T, "deserialize" | TModifiers>;
@@ -29,4 +32,5 @@ export declare class SchemaNumber<T extends number, TModifiers extends SchemaMod
     array(): SchemaArray<this, TModifiers>;
     index(...indexes: string[]): SchemaIndex<T, TModifiers>;
     distinct(): SchemaDistinct<T, "distinct" | TModifiers>;
+    tag(...tags: string[]): SchemaTag<T, TModifiers>;
 }

package/dist/schema/property/types/SchemaObject.d.ts

@@ -5,6 +5,7 @@ import { SchemaFrom } from "../modifiers/SchemaFrom";
 import { SchemaIdentity } from "../modifiers/SchemaIdentity";
 import { SchemaNullable } from "../modifiers/SchemaNullable";
 import { SchemaOptional } from "../modifiers/SchemaOptional";
+import { SchemaTag } from "../modifiers/SchemaTag";
 import { SchemaArray } from "./SchemaArray";
 export declare class SchemaObject<T extends {}, TModifiers extends SchemaModifiers> extends SchemaBase<T, TModifiers> {
     instance: T;
@@ -17,4 +18,5 @@ export declare class SchemaObject<T extends {}, TModifiers extends SchemaModifie
     default<I = never>(value: DefaultValue<T, I>, injected?: I): SchemaDefault<T, I, "default" | TModifiers>;
     identity(): SchemaIdentity<T, "identity" | "readonly" | TModifiers>;
     array(): SchemaArray<this, TModifiers>;
+    tag(...tags: string[]): SchemaTag<T, TModifiers>;
 }

package/dist/schema/property/types/SchemaString.d.ts

@@ -1,8 +1,9 @@
-import { DefaultValue, PropertyDeserializer, PropertySerializer, SchemaModifiers, SchemaTypes } from "../../types";
+import { CompiledSchema, DefaultValue, InferType, PropertyDeserializer, PropertySerializer, SchemaModifiers, SchemaTypes } from "../../types";
 import { SchemaBase } from "../base/SchemaBase";
 import { SchemaDefault } from "../modifiers/SchemaDefault";
 import { SchemaDeserialize } from "../modifiers/SchemaDeserialize";
 import { SchemaDistinct } from "../modifiers/SchemaDistinct";
+import { SchemaForeignKey } from "../modifiers/SchemaForeignKey";
 import { SchemaFrom } from "../modifiers/SchemaFrom";
 import { SchemaIdentity } from "../modifiers/SchemaIdentity";
 import { SchemaIndex } from "../modifiers/SchemaIndex";
@@ -11,6 +12,7 @@ import { SchemaNullable } from "../modifiers/SchemaNullable";
 import { SchemaOptional } from "../modifiers/SchemaOptional";
 import { SchemaReadonly } from "../modifiers/SchemaReadonly";
 import { SchemaSerialize } from "../modifiers/SchemaSerialize";
+import { SchemaTag } from "../modifiers/SchemaTag";
 import { SchemaArray } from "./SchemaArray";
 export declare class SchemaString<T extends string, TModifiers extends SchemaModifiers> extends SchemaBase<T, TModifiers> {
     instance: T;
@@ -21,6 +23,7 @@ export declare class SchemaString<T extends string, TModifiers extends SchemaMod
     optional(): SchemaOptional<T, "optional" | TModifiers>;
     nullable(): SchemaNullable<T, "nullable" | TModifiers>;
     key(): SchemaKey<T, "key" | TModifiers>;
+    foreignKey<K extends {}>(relatingSchema: CompiledSchema<K>, property: keyof InferType<CompiledSchema<K>>): SchemaForeignKey<T, TModifiers, K>;
     default<I = never>(value: DefaultValue<T, I>, injected?: I): SchemaDefault<T, I, "default" | TModifiers>;
     readonly(): SchemaReadonly<T, "readonly" | TModifiers>;
     deserialize(deserializer: PropertyDeserializer<T>): SchemaDeserialize<T, "deserialize" | TModifiers>;
@@ -29,4 +32,5 @@ export declare class SchemaString<T extends string, TModifiers extends SchemaMod
     array(): SchemaArray<this, TModifiers>;
     index(...indexes: string[]): SchemaIndex<T, TModifiers>;
     distinct(): SchemaDistinct<T, "distinct" | TModifiers>;
+    tag(...tags: string[]): SchemaTag<T, TModifiers>;
 }

package/dist/schema/types.d.ts

@@ -1,15 +1,19 @@
-import { SchemaDefinition } from "./SchemaDefinition";
-import { SchemaBase } from "./property/base/SchemaBase";
-import { SchemaArray } from "./property/types/SchemaArray";
-import { SchemaObject } from "./property/types/SchemaObject";
-import { PropertyInfo } from "./PropertyInfo";
-import { DeepPartial } from "../types";
-import { SchemaFunction } from "./table";
-import { SchemaOptional } from "./property/modifiers";
-import { Branded } from "../utilities/types";
+import type { SchemaDefinition } from "./SchemaDefinition";
+import type { SchemaBase } from "./property/base/SchemaBase";
+import type { SchemaArray } from "./property/types/SchemaArray";
+import type { SchemaObject } from "./property/types/SchemaObject";
+import type { PropertyInfo } from "./PropertyInfo";
+import type { DeepPartial } from "../types";
+import type { SchemaFunction } from "./table";
+import type { SchemaOptional } from "./property/modifiers";
+import type { Branded } from "../utilities/types";
 export type DefaultValue<T, I = never> = T | ((injected: I) => T);
 export type FunctionBody<TEntity, TResult> = (entity: TEntity, collectionName: CollectionName) => TResult;
 export type IdType = string | number;
+export type ForeignKey<T extends {}> = {
+    schema: CompiledSchema<T>;
+    property: PropertyInfo<T>;
+};
 export declare enum SchemaTypes {
     Array = "Array",
     Boolean = "Boolean",
@@ -83,7 +87,7 @@ export interface ISchemaSubscription<T extends {}> extends Disposable {
     send(changes: SubscriptionChanges<T>): void;
     onMessage(callback: (changes: SubscriptionChanges<T>) => void): void;
 }
-type Enrich<TEntity extends {}> = {
+export type Enrich<TEntity extends {}> = {
     (entity: InferType<TEntity>, changeTrackingType: ChangeTrackingType): InferType<TEntity>;
     (entity: InferCreateType<TEntity>, changeTrackingType: ChangeTrackingType): InferCreateType<TEntity>;
 };
@@ -95,7 +99,11 @@ export type Preprocess<TEntity extends {}> = {
     (entity: InferCreateType<TEntity>): InferType<TEntity>;
     (entity: InferType<TEntity>): InferType<TEntity>;
 };
+export type SetProperties<TEntity extends {}> = (destination: InferType<TEntity> | InferCreateType<TEntity>, source: InferType<TEntity> | InferCreateType<TEntity>) => void;
 export type CompiledSchemaCore<TEntity extends {}> = Omit<CompiledSchema<TEntity>, "createSubscription">;
+export type CompiledSchemaWithMetadata<TEntity extends {}, TMetadata> = {
+    readonly metadata: TMetadata;
+} & CompiledSchema<TEntity>;
 /**
  * Represents a fully compiled schema with all utilities and metadata for an entity type.
  */
@@ -130,6 +138,8 @@ export type CompiledSchema<TEntity extends {}> = {
     compare: (a: InferType<TEntity>, fromDb: InferType<TEntity>) => boolean;
     /** Deserializes an entity from storage format. */
     deserialize: (entity: InferType<TEntity>) => InferType<TEntity>;
+    /** Sets 1 or many properties from the source object onto the destination object with change tracking. */
+    set: SetProperties<TEntity>;
     /** Combines serializing and preparing an entity for saving. */
     preprocess: Preprocess<TEntity>;
     /** Combines deserializing and enriching an entity for selection. */
@@ -170,6 +180,7 @@ type InferPrimitive<T> = T extends SchemaOptional<infer C, infer __> ? C extends
 export type InferType<T> = T extends CompiledSchema<infer R> ? InferCompiledSchema<R> : T extends {} ? InferCompiledSchema<T> : T;
 export type InferCreateType<T> = T extends CompiledSchema<infer R> ? InferCompiledCreateSchema<R> : T extends {} ? InferCompiledCreateSchema<T> : unknown;
 export type InferMappedType<T> = T extends SchemaBase<infer K, infer __> ? InferType<K> : InferCompiledSchema<T>;
+export type InferRoot<T> = T extends CompiledSchema<infer R> ? R : never;
 type HasModifier<T, K extends keyof T, M extends SchemaModifiers> = T[K] extends SchemaBase<any, infer Mods> ? M extends Mods ? true : false : false;
 type IsPlainProperty<T, K extends keyof T> = [
     HasModifier<T, K, "readonly">,
@@ -180,21 +191,24 @@ type IsPlainProperty<T, K extends keyof T> = [
     false,
     false
 ] ? true : false;
-type IsPlainCreateProperty<T, K extends keyof T> = [
+type IsCreateExcluded<T, K extends keyof T> = [
     HasModifier<T, K, "identity">,
-    HasModifier<T, K, "default">,
     HasModifier<T, K, "computed">,
-    HasModifier<T, K, "unmapped">,
-    HasModifier<T, K, "optional">,
-    HasModifier<T, K, "nullable">
+    HasModifier<T, K, "unmapped">
 ] extends [
     false,
     false,
-    false,
-    false,
+    false
+] ? false : true;
+type IsCreateOptional<T, K extends keyof T> = [
+    HasModifier<T, K, "optional">,
+    HasModifier<T, K, "default">
+] extends [
     false,
     false
-] ? true : false;
+] ? false : true;
+type IsCreateNullable<T, K extends keyof T> = HasModifier<T, K, "nullable"> extends true ? true : false;
+type InferCreateProperty<T, K extends keyof T> = IsCreateNullable<T, K> extends true ? null | InferPrimitive<T[K]> : InferPrimitive<T[K]>;
 type InferCompiledSchema<T> = CoalesceEmpty<{
     [K in keyof T as IsPlainProperty<T, K> extends true ? K : never]: InferPrimitive<T[K]>;
 }, {
@@ -204,15 +218,11 @@ type InferCompiledSchema<T> = CoalesceEmpty<{
 }, {
     [K in keyof T as HasModifier<T, K, "nullable"> extends true ? K : never]: null | InferPrimitive<T[K]>;
 }>;
-type InferCompiledCreateSchema<T> = CoalesceEmpty<{
-    [K in keyof T as IsPlainCreateProperty<T, K> extends true ? K : never]: InferPrimitive<T[K]>;
-}, {
-    [K in keyof T as HasModifier<T, K, "optional"> extends true ? K : never]?: InferPrimitive<T[K]>;
-}, {
-    [K in keyof T as HasModifier<T, K, "default"> extends true ? K : never]?: InferPrimitive<T[K]>;
-}, {
-    [K in keyof T as HasModifier<T, K, "nullable"> extends true ? K : never]: null | InferPrimitive<T[K]>;
-}>;
+type InferCompiledCreateSchema<T> = {
+    [K in keyof T as IsCreateExcluded<T, K> extends true ? never : IsCreateOptional<T, K> extends true ? K : never]?: InferCreateProperty<T, K>;
+} & {
+    [K in keyof T as IsCreateExcluded<T, K> extends true ? never : IsCreateOptional<T, K> extends true ? never : K]: InferCreateProperty<T, K>;
+};
 type IsEmptyObject<T> = keyof T extends never ? true : false;
 type CoalesceEmpty<T1 extends {}, T2 extends {}, T3 extends {}, T4 extends {}> = (IsEmptyObject<T1> extends true ? {} : T1) & (IsEmptyObject<T2> extends true ? {} : T2) & (IsEmptyObject<T3> extends true ? {} : T3) & (IsEmptyObject<T4> extends true ? {} : T4);
 export {};

package/dist/schema/utils/standardJsonSchema.d.ts

@@ -0,0 +1,90 @@
+import { PropertyInfo } from '../PropertyInfo';
+import { CompiledSchema, InferCreateType, InferType } from '../types';
+import { SchemaDefinition } from '../SchemaDefinition';
+/**
+ * Standard JSON Schema V1 interface types
+ * Based on https://standardschema.dev/json-schema
+ */
+export interface StandardTypedV1<Input = unknown, Output = Input> {
+    readonly '~standard': StandardTypedV1.Props<Input, Output>;
+}
+export declare namespace StandardTypedV1 {
+    interface Props<Input = unknown, Output = Input> {
+        readonly version: 1;
+        readonly vendor: string;
+        readonly types?: Types<Input, Output> | undefined;
+    }
+    interface Types<Input = unknown, Output = Input> {
+        readonly input: Input;
+        readonly output: Output;
+    }
+}
+export interface StandardJSONSchemaV1<Input = unknown, Output = Input> {
+    readonly '~standard': StandardJSONSchemaV1.Props<Input, Output>;
+}
+export declare namespace StandardJSONSchemaV1 {
+    interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+        readonly jsonSchema: StandardJSONSchemaV1.Converter;
+    }
+    interface Converter {
+        readonly input: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
+        readonly output: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
+    }
+    type Target = 'draft-2020-12' | 'draft-07' | 'openapi-3.0' | ({} & string);
+    interface Options {
+        readonly target: Target;
+        readonly libraryOptions?: Record<string, unknown> | undefined;
+    }
+}
+/**
+ * Converts a Routier PropertyInfo to a JSON Schema property definition.
+ */
+export declare function propertyInfoToJsonSchema(property: PropertyInfo<any>, target: StandardJSONSchemaV1.Target, visited?: Set<string>, useOutputType?: boolean): Record<string, unknown>;
+/**
+ * Converts a CompiledSchema to a JSON Schema object schema.
+ */
+export declare function compiledSchemaToJsonSchema<T extends {}>(compiledSchema: CompiledSchema<T>, target: StandardJSONSchemaV1.Target, useOutputType?: boolean): Record<string, unknown>;
+/**
+ * Creates Standard JSON Schema V1 props for a compiled schema.
+ */
+export declare function createStandardJsonSchemaProps<T extends {}>(compiledSchema: CompiledSchema<T>): StandardJSONSchemaV1.Props<InferCreateType<T>, InferType<T>>;
+/**
+ * Parses a JSON string containing a JSON Schema and rehydrates it into a Routier SchemaDefinition.
+ * This is a convenience wrapper around `rehydrateSchemaFromJsonSchema` that handles JSON parsing.
+ *
+ * @param jsonString - The JSON string containing the JSON Schema
+ * @param collectionName - The collection name for the schema (if not in x-routier metadata)
+ * @returns A SchemaDefinition that can be compiled
+ * @throws Error if the JSON string is invalid or doesn't contain a valid JSON Schema
+ */
+export declare function rehydrateSchemaFromJsonString(jsonString: string, collectionName?: string): SchemaDefinition<any>;
+/**
+ * Rehydrates a JSON Schema back into a Routier SchemaDefinition.
+ * This parses the JSON Schema structure and reconstructs the schema using Routier's builder API.
+ *
+ * @param jsonSchema - The JSON Schema object to rehydrate
+ * @param collectionName - The collection name for the schema (if not in x-routier metadata)
+ * @returns A SchemaDefinition that can be compiled
+ */
+export declare function rehydrateSchemaFromJsonSchema(jsonSchema: Record<string, unknown>, collectionName?: string): SchemaDefinition<any>;
+/**
+ * Attempts to extract type information from a compiled schema for better type inference.
+ *
+ * Note: TypeScript types are compile-time only, so we can't extract actual type information at runtime.
+ * The Standard JSON Schema spec allows libraries to advertise their inferred types via the `types` property,
+ * but this requires compile-time type information that isn't available at runtime.
+ *
+ * For proper type inference, consumers should use TypeScript's type system:
+ * ```typescript
+ * const schema = s.define("users", { ... }).compile();
+ * type User = InferType<typeof schema>;
+ * type CreateUser = InferCreateType<typeof schema>;
+ * ```
+ *
+ * @param compiledSchema - The compiled schema to extract type info from
+ * @returns A description of the type names (for documentation purposes only)
+ */
+export declare function extractTypeInfo<T extends {}>(compiledSchema: CompiledSchema<T>): {
+    inputType: string;
+    outputType: string;
+};

package/dist/schema/utils/standardJsonSchema.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utilities/functions.d.ts

@@ -1 +1 @@
-export declare const noop: (...args: any[]) => void;
+export declare const noop: (..._args: any[]) => void;