@orion-js/schema 4.0.0-next.3 → 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 };

package/dist/index.js

@@ -41,36 +41,13 @@ var ValidationError = class _ValidationError extends Error {
   };
 };
 
-// src/getValidationErrors/convertTypedModel.ts
-function isClass(obj) {
-  const isCtorClass = obj.constructor && obj.constructor.toString().substring(0, 5) === "class";
-  if (obj.prototype === void 0) {
-    return isCtorClass;
-  }
-  const isPrototypeCtorClass = obj.prototype.constructor && obj.prototype.constructor.toString && obj.prototype.constructor.toString().substring(0, 5) === "class";
-  return isCtorClass || isPrototypeCtorClass;
-}
-var convertOnParam = (info, paramName) => {
-  if (!info[paramName]) return;
-  const type = info[paramName].type;
-  if (!type) return;
-  if (typeof type !== "function") return;
-  if (!isClass(type)) return;
-  if (!type.getModel || !type.__schemaId) return;
-  info[paramName].type = type.getModel().getCleanSchema();
-};
-var convertTypedModel = (info) => {
-  convertOnParam(info, "schema");
-  convertOnParam(info, "currentSchema");
-};
-
-// src/getSchemaFromTypedModel.ts
-var getSchemaFromTypedModel = (schema) => {
+// src/getSchemaFromTypedSchema.ts
+Symbol.metadata ?? (Symbol.metadata = Symbol("Symbol.metadata"));
+var getSchemaFromTypedSchema = (schema) => {
   const item = schema;
-  if (typeof item !== "function") return item;
-  if (!isClass(item)) return item;
-  if (!item.getModel || !item.__schemaId) return item;
-  return item.getModel().getCleanSchema();
+  if (!schema[Symbol.metadata]) return item;
+  if (!schema[Symbol.metadata]._isTypedSchema) return item;
+  return schema[Symbol.metadata]._getModel().getSchema();
 };
 
 // src/getValidationErrors/getError/index.ts
@@ -104,7 +81,8 @@ function fieldType(opts) {
     name,
     validate: overwrittenValidate,
     clean: overwrittenClean,
-    _isFieldType: true
+    __isFieldType: true,
+    __tsFieldType: null
   };
 }
 
@@ -179,12 +157,12 @@ var string_default = fieldType({
   name: "string",
   validate(value, { currentSchema }) {
     if (!isString(value)) return Errors_default.NOT_A_STRING;
-    if (isFinite(currentSchema.min)) {
+    if (Number.isFinite(currentSchema.min)) {
       if (value.length < currentSchema.min) {
         return Errors_default.STRING_TOO_SHORT;
       }
     }
-    if (isFinite(currentSchema.max)) {
+    if (Number.isFinite(currentSchema.max)) {
       if (value.length > currentSchema.max) {
         return Errors_default.STRING_TOO_LONG;
       }
@@ -225,13 +203,13 @@ var date_default = fieldType({
     if (options.autoConvert) {
       if (isString2(value)) {
         const result = new Date(value);
-        if (isNaN(result.getTime())) {
+        if (Number.isNaN(result.getTime())) {
           return value;
         }
         value = result;
       } else if (isNumber(value)) {
         const result = new Date(value);
-        if (isNaN(result.getTime())) {
+        if (Number.isNaN(result.getTime())) {
           return value;
         }
         value = result;
@@ -245,18 +223,17 @@ var date_default = fieldType({
 import isInteger from "lodash/isInteger";
 
 // src/fieldTypes/number.ts
-import isFinite2 from "lodash/isFinite";
 import toNumber from "lodash/toNumber";
 var number_default = fieldType({
   name: "number",
   validate(value, { currentSchema }) {
-    if (!isFinite2(value)) return Errors_default.NOT_A_NUMBER;
-    if (isFinite2(currentSchema.min)) {
+    if (!Number.isFinite(value)) return Errors_default.NOT_A_NUMBER;
+    if (Number.isFinite(currentSchema.min)) {
       if (value < currentSchema.min) {
         return Errors_default.NUMBER_TOO_SMALL;
       }
     }
-    if (isFinite2(currentSchema.max)) {
+    if (Number.isFinite(currentSchema.max)) {
       if (value > currentSchema.max) {
         return Errors_default.NUMBER_TOO_BIG;
       }
@@ -311,10 +288,11 @@ var boolean_default = fieldType({
   clean(value, { options }) {
     if (options.autoConvert) {
       if (typeof value === "string") {
-        if (value === "true") {
+        const stringValue = value;
+        if (stringValue === "true") {
           value = true;
         }
-        if (value === "false") {
+        if (stringValue === "false") {
           value = false;
         }
       }
@@ -363,7 +341,7 @@ var blackbox_default = fieldType({
 // src/fieldTypes/any.ts
 var any_default = fieldType({
   name: "any",
-  validate(value) {
+  validate() {
   }
 });
 
@@ -384,19 +362,19 @@ var fieldTypes_default = {
 
 // src/getValidationErrors/getError/getFieldValidator.ts
 import has from "lodash/has";
-function getFieldValidator_default(type) {
+function getFieldValidator(type) {
   if (isPlainObject4(type)) {
-    if (type._isFieldType) return "custom";
+    if (type.__isFieldType) return "custom";
     return "plainObject";
   }
   if (isArray3(type)) return "array";
   if (type === String) return "string";
-  if (type === Date) return "date";
+  if (typeof type === "function" && type.name === "Date") return "date";
   if (type === Number) return "number";
   if (type === Boolean) return "boolean";
   if (type === "enum") return "string";
   if (!isString5(type)) {
-    throw new Error("Field type is invalid. Pass a string or a custom field type. Got " + type);
+    throw new Error(`Field type is invalid. Pass a string or a custom field type. Got ${type}`);
   }
   const exists = has(fieldTypes_default, type);
   if (!exists) {
@@ -414,7 +392,7 @@ async function getValidationErrors(params) {
       return Errors_default.REQUIRED;
     }
   } else {
-    const validatorKey = getFieldValidator_default(currentSchema.type);
+    const validatorKey = getFieldValidator(currentSchema.type);
     const validator = validatorKey === "custom" ? currentSchema.type : fieldTypes_default[validatorKey];
     const error = await validator.validate(value, info, ...args);
     if (error) {
@@ -444,8 +422,22 @@ import isArray4 from "lodash/isArray";
 import clone from "lodash/clone";
 import isNil3 from "lodash/isNil";
 import difference2 from "lodash/difference";
+
+// src/getValidationErrors/convertTypedSchema.ts
+var convertOnParam = (info, paramName) => {
+  if (!info[paramName]) return;
+  const type = info[paramName].type;
+  if (!type) return;
+  info[paramName].type = getSchemaFromTypedSchema(type);
+};
+var convertTypedSchema = (info) => {
+  convertOnParam(info, "schema");
+  convertOnParam(info, "currentSchema");
+};
+
+// src/getValidationErrors/doValidation.ts
 async function doValidation(params) {
-  convertTypedModel(params);
+  convertTypedSchema(params);
   const { schema, doc, currentDoc, value, currentSchema, keys = [], addError, options, args } = params;
   const info = { schema, doc, currentDoc, value, currentSchema, keys, options, args, addError };
   const error = await getValidationErrors(info);
@@ -457,7 +449,7 @@ async function doValidation(params) {
   if (isPlainObject5(currentSchema.type)) {
     const type = currentSchema.type;
     if (type) {
-      if (type._isFieldType) {
+      if (type.__isFieldType) {
         return;
       }
       if (typeof type.__skipChildValidation === "function") {
@@ -521,10 +513,10 @@ var defaultOptions = {
   omitRequired: false
 };
 async function getValidationErrors2(schema, doc, passedOptions = {}, ...args) {
-  schema = getSchemaFromTypedModel(schema);
+  schema = getSchemaFromTypedSchema(schema);
   const options = { ...defaultOptions, ...passedOptions };
   const errors = [];
-  const addError = function(keys, code) {
+  const addError = (keys, code) => {
     errors.push({
       key: keys.join("."),
       code
@@ -559,7 +551,7 @@ async function isValid(schema, doc, passedOptions = {}, ...args) {
 
 // src/getValidationErrors/getError/getFieldType.ts
 function getFieldType(type) {
-  const validatorKey = getFieldValidator_default(type);
+  const validatorKey = getFieldValidator(type);
   const validator = validatorKey === "custom" ? type : fieldTypes_default[validatorKey];
   return validator;
 }
@@ -606,11 +598,6 @@ async function cleanType(type, fieldSchema, value, info, ...args) {
       value = defaultValue;
     }
   }
-  const { autoValue } = fieldSchema;
-  if (autoValue) {
-    needReClean = true;
-    value = await autoValue(value, info, ...args);
-  }
   const { clean: clean3 } = fieldSchema;
   if (clean3) {
     needReClean = true;
@@ -624,11 +611,11 @@ async function cleanType(type, fieldSchema, value, info, ...args) {
 
 // src/clean/recursiveClean.ts
 import isNil5 from "lodash/isNil";
-var cleanObjectFields = async function({
+var cleanObjectFields = async ({
   schema,
   value,
   ...other
-}) {
+}) => {
   const keys = Object.keys(schema.type).filter((key) => !key.startsWith("__"));
   const newDoc = {};
   for (const key of keys) {
@@ -649,13 +636,13 @@ var cleanObjectFields = async function({
   }
   return newDoc;
 };
-var cleanArrayItems = async function({
+var cleanArrayItems = async ({
   schema,
   value,
   ...other
-}) {
+}) => {
   const schemaType = schema.type[0];
-  const promises = value.map(async (item, index) => {
+  const promises = value.map(async (item) => {
     const newValue = await clean({
       ...other,
       schema: {
@@ -676,9 +663,9 @@ function getArrayNode(schema, value) {
   }
   return null;
 }
-var clean = async function(info) {
-  convertTypedModel(info);
-  let { schema, args = [], value } = info;
+var clean = async (info) => {
+  convertTypedSchema(info);
+  const { schema, args = [], value } = info;
   const currSchema = schema.type === void 0 ? { type: schema } : schema;
   const objectSchema = getObjectNode(currSchema, value);
   if (objectSchema) {
@@ -718,7 +705,7 @@ var defaultOptions2 = {
 };
 async function clean2(schema, doc, opts = {}, ...args) {
   if (!doc) return doc;
-  schema = getSchemaFromTypedModel(schema);
+  schema = getSchemaFromTypedSchema(schema);
   const options = { ...defaultOptions2, ...opts };
   const params = {
     schema: { type: schema },
@@ -743,7 +730,8 @@ var dotGet = function dotGet2(object, path) {
   const levelObject = object.type;
   if (first === "$" || /^[0-9]+$/.test(first)) {
     return dotGet2({ type: levelObject[0] }, remainingPath);
-  } else if (isPlainObject7(levelObject[first])) {
+  }
+  if (isPlainObject7(levelObject[first])) {
     return dotGet2(levelObject[first], remainingPath);
   }
   if (levelObject === "blackbox") {
@@ -789,9 +777,8 @@ async function validateKey_default(schema, key, value, passedOptions = {}, ...ar
   if (!keySchema) {
     if (options.filter) {
       return Errors_default.NOT_IN_SCHEMA;
-    } else {
-      return null;
     }
+    return null;
   }
   if (keySchema.isBlackboxChild) {
     return null;
@@ -853,15 +840,91 @@ function createEnum(name, values) {
     })
   };
 }
+
+// src/models.ts
+Symbol.metadata ?? (Symbol.metadata = Symbol("Symbol.metadata"));
+function isSchemaLike(type) {
+  var _a;
+  if (!type) return false;
+  if (objectHasSubObjectWithKey(type, "type")) return true;
+  if ((_a = type == null ? void 0 : type[Symbol.metadata]) == null ? void 0 : _a._getModel) return true;
+  if (type.getModel) return true;
+  if (type.getSchema) return true;
+  if (type.getCleanSchema) return true;
+  if (type.__isModel) return true;
+  if (type.__modelName) return true;
+  return false;
+}
+function isSchemaOrFieldLike(type) {
+  if (Array.isArray(type)) {
+    if (type.length !== 1) return false;
+    return isSchemaOrFieldLike(type[0]);
+  }
+  if (isSchemaLike(type)) return true;
+  try {
+    if (getFieldValidator(type)) return true;
+  } catch {
+    return false;
+  }
+  return false;
+}
+function getSchemaModelName(type) {
+  if (!type) return null;
+  if (type.__modelName) return type.__modelName;
+  if (type.getModel) return type.getModel().name;
+  if (type.getSchema) return type.getSchema().__modelName;
+  return null;
+}
+function getSchemaFromAnyOrionForm(type) {
+  var _a, _b;
+  if ((_a = type == null ? void 0 : type[Symbol.metadata]) == null ? void 0 : _a._getModel) {
+    return (_b = type == null ? void 0 : type[Symbol.metadata]) == null ? void 0 : _b._getModel().getSchema();
+  }
+  if (type == null ? void 0 : type.getModel) return type.getModel().getSchema();
+  if (type.getSchema) {
+    return type.getSchema();
+  }
+  if (type.getSchema) {
+    return type.getSchema();
+  }
+  if (objectHasSubObjectWithKey(type, "type")) return type;
+  return null;
+}
+function objectHasSubObjectWithKey(object, key) {
+  if (!object || typeof object !== "object") return false;
+  for (const key1 in object) {
+    const value = object[key1];
+    if (value && typeof value === "object" && key in value) {
+      return true;
+    }
+  }
+  return false;
+}
+function getSchemaWithMetadataFromAnyOrionForm(type) {
+  return getSchemaFromAnyOrionForm(type);
+}
+
+// src/schemaWithName/index.ts
+function schemaWithName(name, schema) {
+  schema.__modelName = name;
+  return schema;
+}
 export {
   ValidationError,
   clean2 as clean,
   cleanKey_default as cleanKey,
   createEnum,
   dotGetSchema_default2 as dotGetSchema,
+  fieldTypes_default as fieldTypes,
   getFieldType,
+  getSchemaFromAnyOrionForm,
+  getSchemaModelName,
+  getSchemaWithMetadataFromAnyOrionForm,
   getValidationErrors2 as getValidationErrors,
+  isSchemaLike,
+  isSchemaOrFieldLike,
   isValid,
+  schemaWithName,
   validate,
   validateKey_default as validateKey
 };