@orion-js/schema 4.3.1 → 4.4.0

package/dist/index.d.ts

@@ -1,304 +1,18 @@
-type Constructor<T> = new (...args: any[]) => T;
-type Blackbox = {
-    [name: string]: any;
-};
-type FieldTypesList = 'string' | 'date' | 'integer' | 'number' | 'ID' | 'boolean' | 'email' | 'blackbox' | 'any';
-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 SchemaMetaFieldTypeSingleNonSchema = FieldTypesList | ConstructorsTypesList | FieldType;
-type SchemaMetaFieldTypeSingle = SchemaMetaFieldTypeSingleNonSchema | Schema | TypedSchemaOnSchema;
-type SchemaFieldType = SchemaMetaFieldTypeSingle | SchemaMetaFieldTypeSingle[];
-type SchemaFieldTypeNonSchema = SchemaMetaFieldTypeSingleNonSchema | SchemaMetaFieldTypeSingleNonSchema[];
-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;
-    __GraphQLType?: any;
-    __skipChildValidation?: (value: any, info: CurrentNodeInfo) => Promise<boolean>;
-};
-type SchemaNode<TFieldType extends SchemaFieldType = SchemaFieldType> = {
-    /**
-     * The type of the field. Used for type validations. Can also contain a subschema.
-     */
-    type: TFieldType;
-    /**
-     * Defaults to false
-     */
-    optional?: boolean;
-    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<InferSchemaType<TFieldType>>;
-    /**
-     * Function that preprocesses a value before it is set.
-     */
-    clean?: CleanFunction<InferSchemaType<TFieldType>>;
-    /**
-     * The minimum value if it's a number, the minimum length if it's a string or array.
-     */
-    min?: number;
-    /**
-     * The maximum value if it's a number, the maximum length if it's a string or array.
-     */
-    max?: number;
-    /**
-     * Internal use only.
-     */
-    isBlackboxChild?: boolean;
-    /**
-     * Used in GraphQL. If true, the field will be omitted from the schema.
-     */
-    private?: boolean;
-    /**
-     * Used in GraphQL. When in GraphQL, this resolver will replace the static field.
-     */
-    graphQLResolver?: (...args: any) => any;
-    /**
-     * Used in GraphQL. Sets the key of the field in the GraphQL schema. You must set this value when building your schema.
-     */
-    key?: string;
-    /**
-     * The name that would be displayed in a front-end form
-     */
-    label?: string;
-    /**
-     * The description that would be displayed in a front-end form
-     */
-    description?: string;
-    /**
-     * The placeholder that would be displayed in a front-end form
-     */
-    placeholder?: string;
-    /**
-     * The field type that would be used in a front-end form
-     */
-    fieldType?: string;
-    /**
-     * The field options that will be passed as props to the front-end field
-     */
-    fieldOptions?: any;
-} & SchemaRecursiveNodeTypeExtras;
-interface CurrentNodeInfoOptions {
-    autoConvert?: boolean;
-    filter?: boolean;
-    trimStrings?: boolean;
-    removeEmptyStrings?: boolean;
-    forceDoc?: any;
-    omitRequired?: boolean;
-}
-interface CurrentNodeInfo {
-    /**
-     * The global schema, prefaced by {type: {...}} to be compatible with subschemas
-     * Sometimes it's given without {type: {...}}. TODO: Normalize this.
-     */
-    schema?: SchemaFieldType;
-    /**
-     * The current node subschema
-     */
-    currentSchema?: Partial<SchemaNode<SchemaFieldType>>;
-    value: InferSchemaType<SchemaFieldType>;
-    doc?: any;
-    currentDoc?: any;
-    options?: CurrentNodeInfoOptions;
-    args?: any[];
-    type?: SchemaFieldType;
-    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;
-    /**
-     * The resolvers of the model
-     */
-    __resolvers?: any;
-};
-type Schema = {
-    [K: string]: SchemaNode;
-};
-type SingleLevelSchema = {
-    [K: string]: SchemaNode<SchemaFieldTypeNonSchema>;
-};
-type SchemaInAnyOrionForm = Schema | TypedSchemaOnSchema;
-type SchemaWithMetadata = {
-    [K: string]: SchemaNode | SchemaMetadata[keyof SchemaMetadata];
-} & SchemaMetadata;
-
-interface FieldTypeOpts<TType = any> {
-    name: string;
-    validate?: ValidateFunction<TType>;
-    clean?: CleanFunction<TType>;
-    toGraphQLType?: (GraphQL: any) => any;
-    meta?: any;
-}
-interface FieldType<TType = any> {
-    name: string;
-    validate: ValidateFunction;
-    clean: CleanFunction;
-    meta?: any;
-    toGraphQLType?: (GraphQL: any) => any;
-    toSerializedType?: (node: SchemaNode) => Promise<SchemaFieldType>;
-    __tsFieldType: TType;
-    __isFieldType: boolean;
-}
-
-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 = '__isFieldType' | '__GraphQLType' | '__skipChildValidation';
-type NodeIsOptional<TNode> = TNode extends {
-    optional: true;
-} ? true : false;
-type WithoutNotSchemaItems<T extends Record<string, any>> = T extends {
-    [key in SchemaKeysNotOfSchemaItems]: any;
-} & Record<string, any> ? Omit<T, SchemaKeysNotOfSchemaItems> : T;
-type InferSchemaTypeForSchema<TSchema extends Record<string, any>> = WithoutNotSchemaItems<{
-    -readonly [K in keyof TSchema as NodeIsOptional<TSchema[K]> extends true ? never : K]: InferSchemaType<TSchema[K]['type']>;
-} & {
-    -readonly [K in keyof TSchema as NodeIsOptional<TSchema[K]> extends true ? K : never]?: InferSchemaType<TSchema[K]['type']>;
-}>;
-type IsPossiblyASchema<TType> = TType extends FieldType ? false : 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<T = any> = abstract new (...args: any) => T;
-/**
- * Returns the type of the schema
- */
-type InferSchemaType<TType> = TType extends {
-    __isModel: true;
-    type: infer U;
-} ? InferSchemaTypeForSchema<U> : TType extends SchemaMetaFieldTypeSingleNonSchema ? InferSchemaTypeForFieldType<TType> : TType extends AClass<infer U> ? U : 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>;
-/**
- * Returns the type of the schema but only if its a schema
- */
-type InferSchemaTypeFromTypedSchema<TTypedSchema extends TypedSchemaOnSchema> = TTypedSchema;
-
-declare function validate<TSchema extends SchemaFieldType>(schema: TSchema, doc: InferSchemaType<TSchema>, passedOptions?: {}, ...args: any[]): Promise<void>;
-
-interface ValidationErrorInfo {
-    error: string;
-    message: string;
-    validationErrors: Record<string, string>;
-    labels: Record<string, string>;
-}
-declare class ValidationError extends Error {
-    code: string;
-    isValidationError: boolean;
-    isOrionError: boolean;
-    validationErrors: Record<string, string>;
-    labels: Record<string, string>;
-    constructor(validationErrors: Record<string, string>, labels?: Record<string, string>);
-    getInfo: () => ValidationErrorInfo;
-    prependKey: (prepend: any) => ValidationError;
-}
-
-declare const _default: {
-    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';
-
-type MergeSchemas<SchemaA extends Schema, SchemaB extends Schema> = SchemaA & SchemaB;
-
-declare function getValidationErrors<TSchema extends SchemaFieldType>(schema: TSchema, doc: InferSchemaType<TSchema>, passedOptions?: {}, ...args: any[]): Promise<any>;
-
-declare function isValid<TSchema extends Schema>(schema: TSchema, doc: InferSchemaType<TSchema>, passedOptions?: {}, ...args: any[]): Promise<boolean>;
-
-declare function getFieldType(type: SchemaFieldType | FieldValidatorType | any): FieldType;
-
-declare function clean<TSchema extends SchemaFieldType>(schema: TSchema, 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;
-
-declare function createEnum<const TValues extends readonly string[]>(name: string, values: TValues): FieldType<TValues[number]>;
-
-declare function isSchemaLike(type: any): boolean;
-declare function isStrictSchemaLike<TType extends Schema | SchemaFieldTypeNonSchema>(type: TType): TType extends Schema ? true : false;
-declare function isSchemaOrFieldLike(type: any): boolean;
-declare function getSchemaModelName(type: any): string | null;
-declare function getSchemaFromAnyOrionForm(type: any): SchemaFieldType;
-declare function getSchemaWithMetadataFromAnyOrionForm(type: any): SchemaWithMetadata;
-
-declare function cleanAndValidate<TSchema extends SchemaFieldType>(schema: TSchema, doc: InferSchemaType<TSchema>): Promise<InferSchemaType<TSchema>>;
-
-/**
- * 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;
-
-type CloneSchemaOptions<TSchema extends Schema, TExtendFields extends Schema | undefined = undefined, TPickFields extends (keyof TSchema)[] | undefined = undefined, TOmitFields extends (keyof TSchema)[] | undefined = undefined> = {
-    /**
-     * The schema to clone
-     */
-    schema: TSchema;
-    /**
-     * The name of the cloned schema
-     */
-    name?: string;
-    /**
-     * The schema to extend the cloned schema with
-     */
-    extendSchema?: TExtendFields;
-    /**
-     * A function to map the fields of the cloned schema.
-     * Warning: This function will not be applied to the typescript types of this schema.
-     */
-    mapFields?: (field: TSchema[keyof TSchema], key: keyof TSchema) => SchemaNode;
-    /**
-     * The fields to pick from the cloned schema
-     */
-    pickFields?: TPickFields;
-    /**
-     * The fields to omit from the cloned schema
-     */
-    omitFields?: TOmitFields;
-};
-type ExtendFields<TSchema extends Schema, TExtendFields extends Schema | undefined> = TExtendFields extends undefined ? TSchema : {
-    [key in keyof (TSchema & TExtendFields)]: key extends keyof TExtendFields ? TExtendFields[key] : key extends keyof TSchema ? TSchema[key] : never;
-};
-type PickOrOmit<TSchema extends Schema, TPickFields extends (keyof TSchema)[] | undefined = undefined, TOmitFields extends (keyof TSchema)[] | undefined = undefined> = TPickFields extends undefined ? TOmitFields extends undefined ? TSchema : Omit<TSchema, TOmitFields[number]> : Pick<TSchema, TPickFields[number]>;
-type ClonedSchema<TSchema extends Schema, TExtendFields extends Schema | undefined = undefined, TPickFields extends (keyof TSchema)[] | undefined = undefined, TOmitFields extends (keyof TSchema)[] | undefined = undefined> = ExtendFields<PickOrOmit<TSchema, TPickFields, TOmitFields>, TExtendFields>;
-declare function cloneSchema<TSchema extends Schema, TExtendFields extends Schema | undefined = undefined, TPickFields extends (keyof TSchema)[] | undefined = undefined, TOmitFields extends (keyof TSchema)[] | undefined = undefined>(options: CloneSchemaOptions<TSchema, TExtendFields, TPickFields, TOmitFields>): ClonedSchema<TSchema, TExtendFields, TPickFields, TOmitFields>;
-
-export { type Blackbox, type CleanFunction, type CloneSchemaOptions, type ClonedSchema, type Constructor, type ConstructorsTypesList, type CurrentNodeInfo, type CurrentNodeInfoOptions, type FieldType, type FieldTypeOpts, type FieldTypesList, type FieldValidatorType, type InferSchemaType, type InferSchemaTypeFromTypedSchema, type MergeSchemas, type Schema, type SchemaFieldType, type SchemaFieldTypeNonSchema, type SchemaInAnyOrionForm, type SchemaMetaFieldTypeSingle, type SchemaMetaFieldTypeSingleNonSchema, type SchemaMetadata, type SchemaNode, type SchemaRecursiveNodeTypeExtras, type SchemaWithMetadata, type SingleLevelSchema, type StrictInferSchemaType, type TypedSchemaOnSchema, type ValidateFunction, ValidationError, clean, cleanAndValidate, export_default$2 as cleanKey, cloneSchema, createEnum, export_default as dotGetSchema, _default as fieldTypes, getFieldType, getSchemaFromAnyOrionForm, getSchemaModelName, getSchemaWithMetadataFromAnyOrionForm, getValidationErrors, isSchemaLike, isSchemaOrFieldLike, isStrictSchemaLike, isValid, schemaWithName, validate, export_default$1 as validateKey };
+import validate from './validate';
+import ValidationError from './ValidationError';
+import getValidationErrors from './getValidationErrors';
+import isValid from './isValid';
+import getFieldType from './getValidationErrors/getError/getFieldType';
+import clean from './clean';
+import cleanKey from './cleanKey';
+import validateKey from './validateKey';
+import dotGetSchema from './dotGetSchema';
+import createEnum from './fieldTypes/enum';
+import fieldTypes from './fieldTypes';
+export { validate, ValidationError, getValidationErrors, isValid, getFieldType, clean, cleanKey, dotGetSchema, validateKey, createEnum, fieldTypes, };
+export * from './types';
+export * from './models';
+export * from './cleanAndValidate';
+export * from './fieldType';
+export * from './schemaWithName';
+export * from './cloneSchema';

package/dist/index.js

@@ -861,7 +861,8 @@ function getArrayNode(schema2, value) {
 var clean = async (info) => {
   convertTypedSchema(info);
   const { schema: schema2, args = [], value } = info;
-  const currSchema = schema2.type === void 0 ? { type: schema2 } : schema2;
+  const schemaValue = schema2;
+  const currSchema = typeof schemaValue === "object" && schemaValue !== null && "type" in schemaValue ? schemaValue : { type: schemaValue };
   const objectSchema = getObjectNode(currSchema, value);
   if (objectSchema) {
     const newDoc = await cleanObjectFields({