@xyo-network/object 2.82.0-rc.1 → 2.83.0

package/src/AsObjectFactory.ts

@@ -1,49 +1,8 @@
-import { assertEx } from '@xylabs/assert'
-
-import { ObjectTypeCheck, ObjectTypeConfig } from './IsObjectFactory'
+import { AsTypeFactory, TypeCheck } from './AsTypeFactory'
+import { EmptyObject } from './EmptyObject'
 
 export const AsObjectFactory = {
-  // eslint-disable-next-line @typescript-eslint/ban-types
-  create: <T extends object>(typeCheck: ObjectTypeCheck<T>) => {
-    function func<TObject extends T>(
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      obj: object | undefined | null,
-      config?: ObjectTypeConfig,
-    ): TObject | undefined
-    function func<TObject extends T>(
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      obj: object | undefined | null,
-      assert: string | (() => string),
-      config?: ObjectTypeConfig,
-    ): TObject
-    function func<TObject extends T>(
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      obj: object | undefined | null,
-      assertOrConfig?: string | (() => string) | ObjectTypeConfig,
-      config?: ObjectTypeConfig,
-    ): TObject | undefined {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      const noUndefined = (resolvedAssert: any): resolvedAssert is T => {
-        return !!resolvedAssert
-      }
-
-      if (obj === undefined) {
-        return undefined
-      }
-
-      if (obj === null) {
-        return undefined
-      }
-      const resolvedAssert = typeof assertOrConfig === 'object' ? undefined : assertOrConfig
-      const resolvedConfig = typeof assertOrConfig === 'object' ? assertOrConfig : config
-      const result = typeCheck(obj, resolvedConfig) ? obj : undefined
-
-      if (noUndefined(resolvedAssert)) {
-        return assertEx(result, typeof resolvedAssert === 'function' ? resolvedAssert() : resolvedAssert) as TObject
-      } else {
-        return result as TObject
-      }
-    }
-    return func
+  create: <T extends EmptyObject>(typeCheck: TypeCheck<T>) => {
+    return AsTypeFactory.create<T>(typeCheck)
   },
 }

package/src/AsTypeFactory.ts

@@ -0,0 +1,54 @@
+import { assertEx } from '@xylabs/assert'
+import { Logger } from '@xylabs/logger'
+
+export interface TypeCheckConfig {
+  log?: boolean | Logger
+}
+
+export type TypeCheck<T> = (obj: unknown, config?: TypeCheckConfig) => obj is T
+
+export const AsTypeFactory = {
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  create: <T>(typeCheck: TypeCheck<T>) => {
+    function func<TType extends T>(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      value: unknown,
+      config?: TypeCheckConfig,
+    ): TType | undefined
+    function func<TType extends T>(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      value: unknown,
+      assert: string | (() => string),
+      config?: TypeCheckConfig,
+    ): TType
+    function func<TType extends T>(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      value: unknown,
+      assertOrConfig?: string | (() => string) | TypeCheckConfig,
+      config?: TypeCheckConfig,
+    ): TType | undefined {
+      const noUndefined = (resolvedAssert: unknown): resolvedAssert is T => {
+        return resolvedAssert !== undefined
+      }
+
+      if (value === undefined) {
+        return undefined
+      }
+
+      if (value === null) {
+        return undefined
+      }
+
+      const resolvedAssert = typeof assertOrConfig === 'object' ? undefined : assertOrConfig
+      const resolvedConfig = typeof assertOrConfig === 'object' ? assertOrConfig : config
+      const result = typeCheck(value, resolvedConfig) ? value : undefined
+
+      if (noUndefined(resolvedAssert)) {
+        return assertEx(result, typeof resolvedAssert === 'function' ? resolvedAssert() : resolvedAssert) as TType
+      } else {
+        return result as TType
+      }
+    }
+    return func
+  },
+}

package/src/Base.ts

@@ -0,0 +1,23 @@
+import { Logger } from '@xylabs/logger'
+
+import { EmptyObject } from './EmptyObject'
+
+export type BaseParamsFields = {
+  logger?: Logger
+}
+
+export type BaseParams<TAdditionalParams extends EmptyObject | void = void> = TAdditionalParams extends EmptyObject
+  ? BaseParamsFields & TAdditionalParams
+  : BaseParamsFields
+
+export abstract class Base<TParams extends BaseParams = BaseParams> {
+  static defaultLogger?: Logger
+
+  constructor(readonly params: TParams) {
+    params.logger?.debug(`Base constructed [${Object(this).name}]`)
+  }
+
+  protected get logger() {
+    return this.params?.logger ?? Base.defaultLogger ?? console
+  }
+}

package/src/EmptyObject.ts

@@ -1 +1,8 @@
-export type EmptyObject = { [key: string | number | symbol]: never }
+/**
+ * An empty object, which means that it does enforce the set of field names, defaulting to an empty set until
+ * extended from, which then adds only those additional fields
+ */
+
+export type EmptyObject<T extends object = object> = { [K in keyof T]?: never }
+
+export type EmptyObjectOf<T extends object> = EmptyObject<T> extends T ? EmptyObject<T> : never

package/src/IsObjectFactory.ts

@@ -1,17 +1,12 @@
-import { Logger } from '@xylabs/logger'
-
+import { AnyObject } from './AnyObject'
+import { TypeCheck, TypeCheckConfig } from './AsTypeFactory'
+import { EmptyObject } from './EmptyObject'
 import { isType, ObjectTypeShape } from './isType'
 
-export interface ObjectTypeConfig {
-  log?: boolean | Logger
-}
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/ban-types
-export type ObjectTypeCheck<T extends {} = {}> = (obj: any, config?: ObjectTypeConfig) => obj is T
+export interface ObjectTypeConfig extends TypeCheckConfig {}
 
-// eslint-disable-next-line @typescript-eslint/ban-types
-export class IsObjectFactory<T extends {}> {
-  create(shape?: ObjectTypeShape, additionalChecks?: ObjectTypeCheck[]): ObjectTypeCheck<T> {
+export class IsObjectFactory<T extends EmptyObject> {
+  create(shape?: ObjectTypeShape, additionalChecks?: TypeCheck<AnyObject | EmptyObject>[]): TypeCheck<T> {
     return (obj, { log } = {}): obj is T => {
       if (!obj || typeof obj !== 'object') {
         return false
@@ -19,7 +14,8 @@ export class IsObjectFactory<T extends {}> {
       return (
         //do primary check
         Object.entries(shape ?? {}).reduce((prev, [key, type]) => {
-          const result = isType(obj[key], type)
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          const result = isType((obj as any)[key], type)
           if (!result && log) {
             const logger = typeof log === 'object' ? log : console
             logger.warn(`isType Failed: ${key}: ${type}`)

package/src/Validator.ts

@@ -0,0 +1,13 @@
+import { Promisable } from '@xylabs/promise'
+
+import { AnyObject } from './AnyObject'
+import { EmptyObject } from './EmptyObject'
+import { ObjectWrapper } from './ObjectWrapper'
+
+export interface Validator<T extends EmptyObject = AnyObject> {
+  validate(payload: T): Promisable<Error[]>
+}
+
+export abstract class ValidatorBase<T extends EmptyObject = AnyObject> extends ObjectWrapper<T> implements Validator<T> {
+  abstract validate(payload: T): Promisable<Error[]>
+}

package/src/WithAdditional.ts

@@ -1,3 +1,5 @@
-import { AnyObject } from './AnyObject'
+import { EmptyObject } from './EmptyObject'
 
-export type WithAdditional<T extends AnyObject, TAdditional extends AnyObject | void = void> = TAdditional extends AnyObject ? T & TAdditional : T
+export type WithAdditional<T extends EmptyObject, TAdditional extends EmptyObject | void = void> = TAdditional extends EmptyObject
+  ? T & TAdditional
+  : T

package/src/asObject.ts

@@ -1,5 +1,5 @@
+import { AnyObject } from './AnyObject'
 import { AsObjectFactory } from './AsObjectFactory'
 import { isObject } from './isObject'
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const asObject = (() => AsObjectFactory.create(<T>(obj: T): obj is T => isObject(obj)))()
+export const asAnyObject = (() => AsObjectFactory.create<AnyObject>(<T extends AnyObject>(obj: unknown): obj is T => isObject(obj)))()

package/src/index.ts

@@ -1,6 +1,8 @@
 export * from './AnyObject'
 export * from './asObject'
 export * from './AsObjectFactory'
+export * from './AsTypeFactory'
+export * from './Base'
 export * from './EmptyObject'
 export * from './isObject'
 export * from './IsObjectFactory'
@@ -8,4 +10,5 @@ export * from './isType'
 export * from './JsonObject'
 export * from './ObjectWrapper'
 export * from './StringKeyObject'
+export * from './Validator'
 export * from './WithAdditional'

package/src/isObject.ts

@@ -1,6 +1,6 @@
+import { AnyObject } from './AnyObject'
 import { isType } from './isType'
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const isObject = (value: any): value is Record<string | number | symbol, any> => {
+export const isObject = (value: unknown): value is AnyObject => {
   return isType(value, 'object')
 }