@orion-js/schema 4.0.0-next.2 → 4.0.0-next.4

package/dist/index.d.ts

@@ -1,17 +1,18 @@
-interface FieldTypeOpts {
+interface FieldTypeOpts<TType = any> {
     name: string;
-    validate?: ValidateFunction;
-    clean?: CleanFunction;
+    validate?: ValidateFunction<TType>;
+    clean?: CleanFunction<TType>;
     toGraphQLType?: (GraphQL: any) => any;
     meta?: any;
 }
-interface FieldType {
+interface FieldType<TType = any> {
     name: string;
     validate: ValidateFunction;
     clean: CleanFunction;
     meta?: any;
     toGraphQLType?: (GraphQL: any) => any;
-    _isFieldType: boolean;
+    __tsFieldType: TType;
+    __isFieldType: boolean;
 }
 
 type Constructor<T> = new (...args: any[]) => T;
@@ -19,42 +20,37 @@ type Blackbox = {
     [name: string]: any;
 };
 type FieldTypesList = 'string' | 'date' | 'integer' | 'number' | 'ID' | 'boolean' | 'email' | 'blackbox' | 'any';
-type TypedModelOnSchema = Function;
-type ConstructorsTypesList = Constructor<String> | Constructor<Number> | Constructor<Boolean> | Constructor<Date>;
+type AClass$1 = abstract new (...args: any) => any;
+type TypedSchemaOnSchema = AClass$1;
+type ConstructorsTypesList = Constructor<String> | Constructor<Number> | Constructor<Boolean> | Constructor<Date> | StringConstructor | NumberConstructor | BooleanConstructor | DateConstructor | String | Number | Boolean | Date;
+type SchemaMetaFieldTypeSingle = FieldTypesList | ConstructorsTypesList | Schema | FieldType | TypedSchemaOnSchema;
+type SchemaFieldType = SchemaMetaFieldTypeSingle | SchemaMetaFieldTypeSingle[];
+type ValidateFunction<TType = any> = (value: TType, info?: Partial<CurrentNodeInfo>, ...args: any[]) => object | string | null | undefined | void | Promise<object | string | null | undefined | void>;
+type CleanFunction<TType = any> = (value: TType, info?: Partial<CurrentNodeInfo>, ...args: any[]) => TType | Promise<TType>;
 type SchemaRecursiveNodeTypeExtras = {
-    _isFieldType?: boolean;
-    __clean?: CleanFunction;
-    __validate?: ValidateFunction;
+    __isFieldType?: boolean;
+    __GraphQLType?: any;
     __skipChildValidation?: (value: any, info: CurrentNodeInfo) => Promise<boolean>;
 };
-interface Schema {
-    [key: string]: SchemaNode | Function;
-}
-type SchemaRecursiveNodeType = Schema & SchemaRecursiveNodeTypeExtras;
-type SchemaMetaFieldTypeSingle = FieldTypesList | ConstructorsTypesList | SchemaRecursiveNodeType | FieldType | TypedModelOnSchema;
-type SchemaMetaFieldType = SchemaMetaFieldTypeSingle | SchemaMetaFieldTypeSingle[];
-type ValidateFunction = (value: any, info?: Partial<CurrentNodeInfo>, ...args: any[]) => object | string | void | Promise<object | string | void>;
-type CleanFunction = (value: any, info?: Partial<CurrentNodeInfo>, ...args: any[]) => any | Promise<any>;
-interface SchemaNode {
+type SchemaNode<TFieldType extends SchemaFieldType = SchemaFieldType> = {
     /**
      * The type of the field. Used for type validations. Can also contain a subschema.
      */
-    type: SchemaMetaFieldType;
+    type: TFieldType;
     /**
      * Defaults to false
      */
     optional?: boolean;
-    allowedValues?: Array<any>;
-    defaultValue?: ((info: CurrentNodeInfo, ...args: any[]) => any | Promise<any>) | any;
+    allowedValues?: Array<InferSchemaType<TFieldType>>;
+    defaultValue?: ((info: CurrentNodeInfo, ...args: any[]) => InferSchemaType<TFieldType> | Promise<InferSchemaType<TFieldType>>) | InferSchemaType<TFieldType>;
     /**
      * Function that takes a value and returns an error message if there are any errors. Must return null or undefined otherwise.
      */
-    validate?: ValidateFunction;
+    validate?: ValidateFunction<InferSchemaType<TFieldType>>;
     /**
      * Function that preprocesses a value before it is set.
      */
-    clean?: CleanFunction;
-    autoValue?: (value: any, info: CurrentNodeInfo, ...args: any[]) => any | Promise<any>;
+    clean?: CleanFunction<InferSchemaType<TFieldType>>;
     /**
      * The minimum value if it's a number, the minimum length if it's a string or array.
      */
@@ -67,10 +63,6 @@ interface SchemaNode {
      * Internal use only.
      */
     isBlackboxChild?: boolean;
-    /**
-     * @deprecated
-     */
-    custom?: ValidateFunction;
     /**
      * Used in GraphQL. If true, the field will be omitted from the schema.
      */
@@ -103,7 +95,7 @@ interface SchemaNode {
      * The field options that will be passed as props to the front-end field
      */
     fieldOptions?: any;
-}
+} & SchemaRecursiveNodeTypeExtras;
 interface CurrentNodeInfoOptions {
     autoConvert?: boolean;
     filter?: boolean;
@@ -112,7 +104,7 @@ interface CurrentNodeInfoOptions {
     forceDoc?: any;
     omitRequired?: boolean;
 }
-interface CurrentNodeInfo {
+interface CurrentNodeInfo<TType extends SchemaFieldType = any> {
     /**
      * The global schema, prefaced by {type: {...}} to be compatible with subschemas
      * Sometimes it's given without {type: {...}}. TODO: Normalize this.
@@ -121,18 +113,68 @@ interface CurrentNodeInfo {
     /**
      * The current node subschema
      */
-    currentSchema?: Partial<SchemaNode>;
-    value: any;
+    currentSchema?: Partial<SchemaNode<TType>>;
+    value: TType;
     doc?: any;
     currentDoc?: any;
     options?: CurrentNodeInfoOptions;
     args?: any[];
-    type?: SchemaMetaFieldType;
+    type?: TType;
     keys?: string[];
     addError?: (keys: string[], code: string | object) => void;
 }
+type SchemaMetadata = {
+    /**
+     * The name of the model (to make it compatible with GraphQL)
+     */
+    __modelName?: string;
+    /**
+     * Cleans the whole schema
+     */
+    __clean?: CleanFunction;
+    /**
+     * Validates the whole schema
+     */
+    __validate?: ValidateFunction;
+};
+type Schema = {
+    [K: string]: SchemaNode;
+};
+type SchemaWithMetadata = {
+    [K: string]: SchemaNode | SchemaMetadata[keyof SchemaMetadata];
+} & SchemaMetadata;
 
-declare function validate(schema: Schema | Function, doc: any, passedOptions?: {}, ...args: any[]): Promise<void>;
+type InferSchemaTypeForFieldType<T> = T extends {
+    __tsFieldType: infer U;
+} ? U : T extends 'string' ? string : T extends 'date' ? Date : T extends 'integer' ? number : T extends 'number' ? number : T extends 'ID' ? string : T extends 'boolean' ? boolean : T extends 'email' ? string : T extends 'blackbox' ? Blackbox : T extends 'any' ? any : T extends String ? string : T extends Number ? number : T extends Boolean ? boolean : T extends Date ? Date : T extends StringConstructor ? string : T extends NumberConstructor ? number : T extends BooleanConstructor ? boolean : T extends DateConstructor ? Date : T extends Array<infer U> ? InferSchemaTypeForFieldType<U>[] : T extends Record<string, any> ? InferSchemaTypeForSchema<T> : T;
+type SchemaKeysNotOfSchemaItems = keyof SchemaRecursiveNodeTypeExtras;
+type NodeIsOptional<TNode> = TNode extends {
+    optional: true;
+} ? true : TNode extends {
+    defaultValue: any;
+} ? true : false;
+type InferSchemaTypeForSchema<TSchema extends Record<string, any>> = Omit<{
+    -readonly [K in keyof TSchema as NodeIsOptional<TSchema[K]> extends true ? never : K]: InferSchemaTypeForFieldType<TSchema[K]['type']>;
+} & {
+    -readonly [K in keyof TSchema as NodeIsOptional<TSchema[K]> extends true ? K : never]?: InferSchemaTypeForFieldType<TSchema[K]['type']>;
+}, SchemaKeysNotOfSchemaItems>;
+type IsPossiblyASchema<TType> = TType extends Record<string, any> ? keyof {
+    [K in keyof TType as 'type' extends keyof TType[K] ? K : never]: TType[K];
+} extends never ? false : true : false;
+type AClass = abstract new (...args: any) => any;
+/**
+ * Returns the type of the schema
+ */
+type InferSchemaType<TType> = TType extends {
+    __isModel: true;
+    type: infer U;
+} ? InferSchemaTypeForSchema<U> : TType extends AClass ? InstanceType<TType> : IsPossiblyASchema<TType> extends true ? InferSchemaTypeForSchema<TType> : InferSchemaTypeForFieldType<TType>;
+/**
+ * Returns the type of the schema but only if its a schema
+ */
+type StrictInferSchemaType<TSchema extends Schema> = InferSchemaTypeForSchema<TSchema>;
+
+declare function validate<TSchema extends Schema = Schema>(schema: TSchema | Function, doc: InferSchemaType<TSchema>, passedOptions?: {}, ...args: any[]): Promise<void>;
 
 interface ValidationErrorInfo {
     error: string;
@@ -154,37 +196,56 @@ declare function getValidationErrors(schema: Schema | Function, doc: any, passed
 declare function isValid(schema: Schema, doc: any, passedOptions?: {}, ...args: any[]): Promise<boolean>;
 
 declare const _default: {
-    array: FieldType;
-    plainObject: FieldType;
-    string: FieldType;
-    date: FieldType;
-    integer: FieldType;
-    number: FieldType;
-    ID: FieldType;
-    boolean: FieldType;
-    email: FieldType;
-    blackbox: FieldType;
-    any: FieldType;
+    array: FieldType<any[]>;
+    plainObject: FieldType<Blackbox>;
+    string: FieldType<string>;
+    date: FieldType<Date>;
+    integer: FieldType<number>;
+    number: FieldType<number>;
+    ID: FieldType<string>;
+    boolean: FieldType<boolean>;
+    email: FieldType<string>;
+    blackbox: FieldType<Blackbox>;
+    any: FieldType<any>;
 };
 
 type FieldValidatorType = keyof typeof _default | 'custom' | 'plainObject';
 
-declare function getFieldType(type: SchemaMetaFieldType | FieldValidatorType | any): FieldType;
+declare function getFieldType(type: SchemaFieldType | FieldValidatorType | any): FieldType;
+
+type MergeSchemas<SchemaA extends Schema, SchemaB extends Schema> = SchemaA & SchemaB;
 
-declare function clean<TDoc = Blackbox>(schema: Schema | Function, doc: TDoc, opts?: CurrentNodeInfoOptions, ...args: any[]): Promise<TDoc>;
+declare function clean<TSchema extends Schema = Schema>(schema: TSchema | Function, doc: InferSchemaType<TSchema>, opts?: CurrentNodeInfoOptions, ...args: any[]): Promise<InferSchemaType<TSchema>>;
 
 declare function export_default$2(schema: any, key: any, value: any, passedOptions?: {}, ...args: any[]): Promise<any>;
 
 declare function export_default$1(schema: Schema, key: string, value: any, passedOptions?: CurrentNodeInfoOptions, ...args: any[]): Promise<any>;
 
-declare function export_default(schema: Schema, path: string): SchemaNode | {
-    type: string;
-    optional: boolean;
-    isBlackboxChild: boolean;
-};
+declare function export_default(schema: Schema, path: string): SchemaNode;
 
-declare function createEnum<TValues extends readonly string[]>(name: string, values: TValues): FieldType & {
+declare function createEnum<const TValues extends readonly string[]>(name: string, values: TValues): FieldType<TValues[number]> & {
     type: TValues[number];
 };
 
-export { type Blackbox, type CleanFunction, type Constructor, type ConstructorsTypesList, type CurrentNodeInfo, type CurrentNodeInfoOptions, type FieldType, type FieldTypeOpts, type FieldTypesList, type FieldValidatorType, type Schema, type SchemaMetaFieldType, type SchemaMetaFieldTypeSingle, type SchemaNode, type SchemaRecursiveNodeType, type SchemaRecursiveNodeTypeExtras, type TypedModelOnSchema, type ValidateFunction, ValidationError, clean, export_default$2 as cleanKey, createEnum, export_default as dotGetSchema, getFieldType, getValidationErrors, isValid, validate, export_default$1 as validateKey };
+declare function isSchemaLike(type: any): boolean;
+declare function isSchemaOrFieldLike(type: any): boolean;
+declare function getSchemaModelName(type: any): string | null;
+declare function getSchemaFromAnyOrionForm(type: any): Schema;
+declare function getSchemaWithMetadataFromAnyOrionForm(type: any): SchemaWithMetadata;
+
+/**
+ * Assigns a name to a schema for GraphQL type generation.
+ *
+ * This function associates a name with a schema object by setting an internal
+ * `__modelName` property. This name is used when generating GraphQL types.
+ *
+ * @param name - The name to assign to the schema
+ * @param schema - The schema object to name
+ * @returns The same schema object with the internal name property added
+ *
+ * Note: The schema object is modified in-place, so the name will persist
+ * even if you don't use the returned value.
+ */
+declare function schemaWithName<TModelName extends string, TSchema extends Schema>(name: TModelName, schema: TSchema): TSchema;
+
+export { type Blackbox, type CleanFunction, type Constructor, type ConstructorsTypesList, type CurrentNodeInfo, type CurrentNodeInfoOptions, type FieldType, type FieldTypeOpts, type FieldTypesList, type FieldValidatorType, type InferSchemaType, type MergeSchemas, type Schema, type SchemaFieldType, type SchemaMetaFieldTypeSingle, type SchemaMetadata, type SchemaNode, type SchemaRecursiveNodeTypeExtras, type SchemaWithMetadata, type StrictInferSchemaType, type TypedSchemaOnSchema, type ValidateFunction, ValidationError, clean, export_default$2 as cleanKey, createEnum, export_default as dotGetSchema, _default as fieldTypes, getFieldType, getSchemaFromAnyOrionForm, getSchemaModelName, getSchemaWithMetadataFromAnyOrionForm, getValidationErrors, isSchemaLike, isSchemaOrFieldLike, isValid, schemaWithName, validate, export_default$1 as validateKey };