@quatrain/core 1.1.24 → 1.1.28

package/src/components/ObjectUri.test.ts

@@ -0,0 +1,74 @@
+import { ObjectUri } from './ObjectUri'
+
+describe('Object Uri', () => {
+   test('relative uri', () => {
+      const uri = new ObjectUri('collection/uid', 'a label')
+      //expect(uri.backend).toBe('@default')
+      expect(uri.path).toBe('collection/uid')
+      //expect(uri.literal).toBe('@default:collection/uid')
+      expect(uri.collection).toBe('collection')
+      expect(uri.uid).toBe('uid')
+      expect(uri.label).toBe('a label')
+   })
+
+   test('relative uri with sub collection', () => {
+      const uri = new ObjectUri('collection/uid/subcollection/sid', 'a label')
+      //expect(uri.backend).toBe('@default')
+    //  expect(uri.path).toBe('subcollection/sid')
+   //   expect(uri.literal).toBe('@default:collection/uid/subcollection/sid')
+      expect(uri.collection).toBe('subcollection')
+      expect(uri.uid).toBe('sid')
+      expect(uri.label).toBe('a label')
+   })
+
+   test('uri with backend', () => {
+      const uri = new ObjectUri('@backend:collection/uid', 'a label')
+      expect(uri.backend).toBe('@backend')
+      expect(uri.path).toBe('collection/uid')
+      expect(uri.literal).toBe('@backend:collection/uid')
+      expect(uri.collection).toBe('collection')
+      expect(uri.uid).toBe('uid')
+      expect(uri.label).toBe('a label')
+   })
+
+   test('uri represents a subcollections-based path', () => {
+      const path = 'collection1/uid1/collection2/uid2/collection3/uid3'
+      const uri = new ObjectUri(path, 'a subcollections-based path')
+      //expect(uri.backend).toBe('@default')
+  //    expect(uri.path).toBe('collection3/uid3')
+  //    expect(uri.literal).toBe(`@default:${path}`)
+      expect(uri.collection).toBe('collection3')
+      expect(uri.uid).toBe('uid3')
+      expect(uri.parent).toBeInstanceOf(ObjectUri)
+   //   expect(uri.parent?.literal).toBe('@default:collection1/uid1/collection2/uid2')
+      expect(uri.parent?.collection).toBe('collection2')
+   //   expect(uri.parent?.path).toBe('collection2/uid2')
+      expect(uri.parent?.parent).toBeInstanceOf(ObjectUri)
+   //   expect(uri.parent?.parent?.literal).toBe('@default:collection1/uid1')
+      expect(uri.parent?.parent?.collection).toBe('collection1')
+      expect(uri.parent?.parent?.path).toBe('collection1/uid1')
+      expect(uri.label).toBe('a subcollections-based path')
+   })
+
+   test('uri points to file', () => {
+      const uri = new ObjectUri('@s3:path/to/file.ext', 'a file')
+      expect(uri.backend).toBe('@s3')
+      expect(uri.path).toBe('path/to/file.ext')
+      expect(uri.literal).toBe('@s3:path/to/file.ext')
+      expect(uri.collection).toBeUndefined()
+      expect(uri.uid).toBe('file.ext')
+      expect(uri.label).toBe('a file')
+   })
+
+   test('uri without collection', () => {
+      const uri = new ObjectUri('uid')
+   //   expect(uri.backend).toBe('@default')
+      expect(uri.path).toBe('uid')
+      //expect(uri.literal).toBe(`@default:${ObjectUri.MISSING_COLLECTION}/uid`)
+      expect(uri.collection).toBeUndefined()
+      expect(uri.uid).toBe('uid')
+
+      uri.collection = 'collection'
+      expect(uri.collection).toBe('collection')
+   })
+})

package/src/components/ObjectUri.ts

@@ -0,0 +1,174 @@
+export class ObjectUri {
+   static DEFAULT = '/'
+   static MISSING_COLLECTION = '_?_'
+
+   protected _str: string
+   protected _pairs: Array<string> = []
+   protected _literal: string = ''
+   protected _backend: string | undefined
+   protected _path: string = ObjectUri.DEFAULT
+   protected _uid: string | undefined = undefined
+   protected _collection: string | undefined = undefined
+   protected _label: string | undefined = ''
+   protected _objClass: any
+   protected _parent: ObjectUri | undefined
+
+   /**
+    * create object uri from string:
+    * ex: 'xyz', '@backend:xyz', 'collection/xyz', '@backend:collection/xyz'
+    * some backends will need a collection or table name, some may deduct it from object
+    * @param str partial or full resource path
+    * @param label optional label to describe path
+    */
+   constructor(str: string = '', label: string | undefined = '') {
+      this._str = str
+      this._label = label
+      if (str.includes(':')) {
+         const [backend, path] = str.split(':')
+         this._backend = backend
+         this._path = path
+      } else {
+         this._path = str
+      }
+      const parts = this._path.split(ObjectUri.DEFAULT)
+      const isFilePath = parts[parts.length - 1].indexOf('.') !== -1
+
+      if (isFilePath) {
+         this._uid = parts[parts.length - 1]
+      } else if (parts.length === 1) {
+         // It is allowed to only give the uid part of the uri
+         // provided that collection will be injected by another means
+         this._uid = parts[0].length > 0 ? parts[0] : undefined
+         this._collection = ObjectUri.MISSING_COLLECTION
+         this._pairs.push(
+            `${ObjectUri.MISSING_COLLECTION}${ObjectUri.DEFAULT}${this._uid}`
+         )
+         this._label = label || this._uid
+      } else if (parts.length % 2 === 0) {
+         this._path = parts.slice(parts.length - 2).join(ObjectUri.DEFAULT)
+         this._uid = parts[parts.length - 1]
+         this._collection = parts[parts.length - 2]
+         if (parts.length > 2) {
+            this._parent = new ObjectUri(
+               parts.slice(0, parts.length - 2).join(ObjectUri.DEFAULT)
+            )
+         }
+         this._label = label || this._uid
+      } else if (!isFilePath) {
+         // if the last part is not a filename with extension, throw error
+         throw new Error(
+            `Path parts number must be 1 or even, received: '${str}'`
+         )
+      }
+   }
+
+   set class(objClass: any) {
+      this._objClass = objClass
+      if (objClass) {
+         this._collection =
+            objClass.COLLECTION ||
+            (objClass.name && objClass.name.toLowerCase())
+      } else {
+         this._collection = undefined
+      }
+   }
+
+   get class() {
+      return this._objClass
+   }
+
+   get backend() {
+      return this._backend
+   }
+
+   /**
+    * Returns the full path of the resource
+    * including optional parents' path
+    * @returns string
+    */
+   get path() {
+      return this._parent
+         ? `${this._parent.path}${ObjectUri.DEFAULT}${this._path}`
+         : this._path
+   }
+
+   /**
+    * Returns the own path of the resource
+    * without the optional parents' paths
+    * @returns string
+    */
+   get ownPath() {
+      return this._path
+   }
+
+   get parent() {
+      return this._parent
+   }
+
+   set label(label: string | undefined) {
+      this._label = label
+   }
+
+   get label() {
+      return this._label
+   }
+
+   /**
+    * Return the full path litteral
+    * including the backend alias
+    * @returns string
+    */
+   get literal() {
+      return this._str.includes(':')
+         ? this._str
+         : `${this._backend}:${this._str}`
+   }
+
+   set path(path: string) {
+      // if (this._path && this._path !== ObjectUri.DEFAULT) {
+      //    throw new Error(`Path value already set with '${this._path}'`)
+      // }
+      this._path = path
+      // TODO manage paths to subcollection
+      this._collection = path.split('/')[0]
+      this._literal = `${this._backend}:${this._path}`
+      this._uid = path.split('/').pop()
+   }
+
+   get uid() {
+      return this._uid
+   }
+
+   get collection(): string | undefined {
+      return this._collection === ObjectUri.MISSING_COLLECTION
+         ? undefined
+         : this._collection
+   }
+
+   set collection(collection: string | undefined) {
+      if (this.collection !== undefined) {
+         throw new Error('Collection value already set')
+      }
+      this._collection = collection
+   }
+
+   /**
+    * Return references to find object locally and remotely
+    * @returns object
+    */
+   toReference() {
+      return {
+         ref: this.path,
+         uri: this._literal,
+         label: this._label,
+      }
+   }
+
+   toJSON() {
+      return {
+         backend: this._backend,
+         ref: this.path,
+         label: this._label || '',
+      }
+   }
+}

package/src/components/User.ts

@@ -0,0 +1,111 @@
+import { BaseObject } from './BaseObject'
+import { DataObjectClass } from './types/DataObjectClass'
+import { DateTimeProperty, EnumProperty, ObjectProperty } from '../properties'
+import { HashProperty } from '../properties/HashProperty'
+import { StringProperty } from '../properties/StringProperty'
+import * as htmlType from '../properties/types/PropertyHTMLType'
+import { BaseObjectProperties } from './BaseObjectProperties'
+import { BaseObjectType } from './types/BaseObjectType'
+
+export interface UserType extends BaseObjectType {
+   firstname: string
+   lastname: string
+   gender?: 'male' | 'female' | 'nonbinary'
+   birthday?: Date
+   password: string
+   email: string
+   [x: string]: any
+}
+
+/**
+ * Callback function to populate the 'name' property
+ * @param dao DataObject
+ * @returns
+ */
+const onChange = (dao: DataObjectClass<any>) =>
+   dao.set('name', `${dao.val('firstname')} ${dao.val('lastname')}`)
+
+export const UserProperties: any = [
+   ...BaseObjectProperties,
+   {
+      // change name property minLength
+      name: 'name',
+      type: StringProperty.TYPE,
+      minLength: 0,
+      htmlType: htmlType.NAME,
+   },
+   {
+      name: 'firstname',
+      mandatory: true,
+      type: StringProperty.TYPE,
+      minLength: 1,
+      maxLength: 100,
+      fullSearch: true,
+      htmlType: htmlType.GIVEN_NAME,
+      onChange,
+   },
+   {
+      name: 'lastname',
+      mandatory: true,
+      type: StringProperty.TYPE,
+      minLength: 1,
+      maxLength: 100,
+      fullSearch: true,
+      htmlType: htmlType.FAMILY_NAME,
+      onChange,
+   },
+   {
+      name: 'gender',
+      mandatory: false,
+      type: EnumProperty.TYPE,
+      values: ['male', 'female', 'nonbinary'],
+      htmlType: htmlType.GENDER,
+   },
+   {
+      name: 'birthday',
+      mandatory: false,
+      type: DateTimeProperty.TYPE,
+      htmlType: htmlType.BIRTHDAY,
+   },
+   {
+      name: 'email',
+      mandatory: true,
+      type: StringProperty.TYPE,
+      minLength: 1,
+      maxLength: 100,
+      fullSearch: true,
+      htmlType: htmlType.EMAIL,
+   },
+   {
+      name: 'phone',
+      type: StringProperty.TYPE,
+      minLength: 1,
+      maxLength: 100,
+      htmlType: htmlType.OFF,
+   },
+   {
+      name: 'password',
+      mandatory: true,
+      type: HashProperty.TYPE,
+      algorithm: HashProperty.ALGORITHM_SHA256,
+      salt: '', // you should override it in your code
+      minLength: 5,
+      maxLength: 20, // this is for the clear password
+      htmlType: htmlType.PASSWORD,
+   },
+   {
+      name: 'entity',
+      mandatory: false,
+      type: ObjectProperty.TYPE,
+      instanceOf: 'Entity',
+   },
+]
+
+export class User extends BaseObject {
+   static PROPS_DEFINITION = UserProperties
+   static COLLECTION = 'user'
+
+   static async factory(src: any = undefined): Promise<User> {
+      return super.factory(src, User)
+   }
+}

package/src/components/index.ts

@@ -0,0 +1,19 @@
+import { DataObject } from './DataObject'
+import { DataObjectClass } from './types/DataObjectClass'
+import { DataObjectParams } from './types/DataObjectParams'
+import { ObjectUri } from './ObjectUri'
+import { AbstractObject } from './AbstractObject'
+import { BaseObjectProperties } from './BaseObjectProperties'
+import { User, UserProperties } from './User'
+import { Entity } from './Entity'
+
+export {
+   DataObject,
+   ObjectUri,
+   AbstractObject,
+   User,
+   Entity,
+   BaseObjectProperties,
+   UserProperties,
+}
+export type { DataObjectParams, DataObjectClass }

package/src/components/types/AbstractObjectClass.ts

@@ -0,0 +1,7 @@
+import { DataObjectClass } from './DataObjectClass'
+
+export interface AbstractObjectClass {
+   dataObject: DataObjectClass<any>
+   asReference(): any
+   val(val: string): any
+}

package/src/components/types/BaseObjectClass.ts

@@ -0,0 +1,8 @@
+import { AbstractObjectClass } from './AbstractObjectClass'
+import { DataObjectClass } from './DataObjectClass'
+
+export interface BaseObjectClass extends AbstractObjectClass {
+   dataObject: DataObjectClass<any>
+   asReference(): any
+   save(): Promise<this>
+}

package/src/components/types/BaseObjectType.ts

@@ -0,0 +1,10 @@
+export interface BaseObjectType {
+   name: string
+   status?: string
+   createdBy?: any
+   createdAt?: number | string
+   updatedBy?: any
+   updatedAt?: number | string
+   deletedBy?: any
+   deletedAt?: number | string
+}

package/src/components/types/DataObjectClass.ts

@@ -0,0 +1,27 @@
+import { PropertyClassType } from '../../properties/types/PropertyClassType'
+import { ObjectUri } from '../ObjectUri'
+import { toJSONParams } from './toJSONParams'
+
+export interface DataObjectClass<T extends DataObjectClass<any>> {
+   uri: ObjectUri
+   uid: any
+   path: any
+   class: any
+   properties: any
+   parentProp: string | undefined
+
+   setProperties(properties: any): void
+   getProperties(type: any): any
+   addProperty(property: PropertyClassType): void
+   populate(data?: any): Promise<T>
+   isPopulated(): boolean
+   has(key: string): boolean
+   get(key: string): any
+   set(key: string, val: any): any
+   val(key: string): any
+   clone(data?: any): Promise<T>
+   toReference(): any
+   toJSON(params?: boolean | toJSONParams): any
+   populateFromData(data: { [x: string]: unknown }): this
+   asProxy(): any
+}

package/src/components/types/DataObjectParams.ts

@@ -0,0 +1,8 @@
+import { DataObjectProperties } from '../../properties'
+import { ObjectUri } from '../ObjectUri'
+
+export interface DataObjectParams {
+   uri?: string | ObjectUri
+   properties: DataObjectProperties
+   parentProp?: string
+}

package/src/components/types/DataObjectType.ts

@@ -0,0 +1,27 @@
+import { PropertyClassType } from '../../properties/types/PropertyClassType'
+import { ObjectUri } from '../ObjectUri'
+import { toJSONParams } from './toJSONParams'
+
+export interface DataObjectType {
+   uri: ObjectUri
+   uid: any
+   path: any
+   class: any
+   properties: any
+   parentProp: string | undefined
+
+   setProperties(properties: any): void
+   getProperties(type: any): any
+   addProperty(property: PropertyClassType): void
+   populate(data?: any): Promise<any>
+   isPopulated(): boolean
+   has(key: string): boolean
+   get(key: string): any
+   set(key: string, val: any): any
+   val(key: string): any
+   clone(data?: any): Promise<any>
+   toReference(): any
+   toJSON(params?: boolean | toJSONParams): any
+   populateFromData(data: { [x: string]: unknown }): this
+   asProxy(): any
+}

package/src/components/types/EntityClass.ts

@@ -0,0 +1,3 @@
+import { BaseObjectClass } from './BaseObjectClass'
+
+export interface EntityClass extends BaseObjectClass {}

package/src/components/types/Payload.ts

@@ -0,0 +1,11 @@
+import { BaseObjectType } from './BaseObjectType'
+
+export default interface Payload<T extends BaseObjectType> {
+   items: T[]
+   meta: Meta
+}
+
+export interface Meta {
+   count: number
+   updatedAt: number
+}

package/src/components/types/Persisted.ts

@@ -0,0 +1,7 @@
+import { ObjectUri } from '../ObjectUri'
+import { Proxy } from './ProxyConstructor'
+
+export type Persisted<T> = {
+   uid: string
+   uri: ObjectUri
+} & Proxy<T>

package/src/components/types/Properties.ts

@@ -0,0 +1 @@
+type Properties<T> = { name: keyof T }[]

package/src/components/types/ProxyConstructor.ts

@@ -0,0 +1,13 @@
+import { BaseObjectClass } from './BaseObjectClass'
+
+interface ProxyConstructor {
+   new <T extends object, H>(target: T, handler: ProxyHandler<T>): Proxy<H>
+}
+
+export const ProxyConstructor = Proxy as ProxyConstructor
+
+export type Proxy<T> = T & {
+   readonly toJSON: () => object
+   readonly core: BaseObjectClass
+   //save: () => Promise<void>
+}

package/src/components/types/toJSONParams.ts

@@ -0,0 +1,12 @@
+export type toJSONParams = {
+   // Return objects as references
+   objectsAsReferences?: boolean
+   // Exclude URI data (uid, patch, etc.)
+   withoutURIData?: boolean
+   // Ignore property which value has not been changed
+   ignoreUnchanged?: boolean
+   // Ignore property which value is null
+   ignoreNulls?: boolean
+   // map of property values converters
+   converters?: { [propType: string]: Function }
+}

package/src/index.ts

@@ -0,0 +1,97 @@
+import { Core } from './Core'
+import * as statuses from './common/statuses'
+import { Property } from './properties/Property'
+import { BaseProperty, BasePropertyType } from './properties/BaseProperty'
+import { StringProperty, StringPropertyType } from './properties/StringProperty'
+import { NumberProperty, NumberPropertyType } from './properties/NumberProperty'
+import { EnumProperty, EnumPropertyType } from './properties/EnumProperty'
+import {
+   BooleanProperty,
+   BooleanPropertyType,
+} from './properties/BooleanProperty'
+import {
+   ObjectProperty,
+   ObjectPropertyType,
+   returnAs,
+} from './properties/ObjectProperty'
+import {
+   DateTimeProperty,
+   DateTimePropertyType,
+} from './properties/DateTimeProperty'
+import { HashProperty, HashPropertyType } from './properties/HashProperty'
+import {
+   CollectionProperty,
+   CollectionPropertyType,
+} from './properties/CollectionProperty'
+import { ArrayProperty, ArrayPropertyType } from './properties/ArrayProperty'
+import { AbstractObject } from './components/AbstractObject'
+import { ObjectUri } from './components/ObjectUri'
+import { DataObjectClass } from './components/types/DataObjectClass'
+import { DataObject } from './components/DataObject'
+import { DataObjectProperties } from './properties'
+import { BaseObject } from './components/BaseObject'
+import { BaseObjectProperties } from './components/BaseObjectProperties'
+import { BaseObjectType } from './components/types/BaseObjectType'
+import { Proxy } from './components/types/ProxyConstructor'
+
+import { UserType, User, UserProperties } from './components/User'
+import { EntityType, Entity } from './components/Entity'
+
+import {
+   BadRequestError,
+   UnauthorizedError,
+   ForbiddenError,
+   NotFoundError,
+   GoneError,
+} from './common/ResourcesErrors'
+import { DataObjectParams } from './components/types/DataObjectParams'
+
+export {
+   statuses,
+   Core,
+   Property,
+   BaseProperty,
+   BooleanProperty,
+   DateTimeProperty,
+   EnumProperty,
+   HashProperty,
+   CollectionProperty,
+   ArrayProperty,
+   ObjectProperty,
+   NumberProperty,
+   returnAs,
+   StringProperty,
+   ObjectUri,
+   DataObject,
+   AbstractObject,
+   BaseObject,
+   BaseObjectProperties,
+   User,
+   UserProperties,
+   Entity,
+   BadRequestError,
+   UnauthorizedError,
+   ForbiddenError,
+   NotFoundError,
+   GoneError,
+}
+
+export type {
+   BasePropertyType,
+   BooleanPropertyType,
+   DataObjectParams,
+   DateTimePropertyType,
+   EnumPropertyType,
+   HashPropertyType,
+   CollectionPropertyType,
+   ArrayPropertyType,
+   ObjectPropertyType,
+   NumberPropertyType,
+   StringPropertyType,
+   DataObjectClass,
+   DataObjectProperties,
+   BaseObjectType,
+   UserType,
+   Proxy,
+   EntityType,
+}

package/src/properties/ArrayProperty.test.ts

@@ -0,0 +1,46 @@
+import { ArrayProperty } from './ArrayProperty'
+import { StringProperty } from './StringProperty'
+
+const arrayValue = ['ab', 'cd', 'ef']
+const transformer = (array: Array<string>) => array.join()
+
+describe('Array Property without digits', () => {
+   const prop = new ArrayProperty({ name: 'toto', allowNumbers: false })
+   test('allow numbers is not set', () =>
+      expect(prop.allows).not.toContain(StringProperty.ALLOW_NUMBERS))
+   test('no numbers allowed', () => expect(() => prop.set([123])).toThrow())
+})
+
+describe('Array Property without strings', () => {
+   const prop = new ArrayProperty({ name: 'toto', allowStrings: false })
+   test('allow strings is not set', () =>
+      expect(prop.allows).not.toContain(StringProperty.ALLOW_STRINGS))
+   test('no strings allowed', () => expect(() => prop.set(['value'])).toThrow())
+})
+
+describe('Array Property with minimal length', () => {
+   const prop = new ArrayProperty({ name: 'toto', minLength: 3 })
+   test('minlength is set', () => expect(prop.minLength).toBeGreaterThan(0))
+   test('minimum length of 3', () =>
+      expect(() => prop.set(['value', 123])).toThrow())
+})
+
+describe('Array Property with maximal length', () => {
+   const prop = new ArrayProperty({ name: 'toto', maxLength: 2 })
+   test('maxlength is set', () => expect(prop.maxLength).toBeGreaterThan(0))
+   test('maximum length of 2', () =>
+      expect(() => prop.set(['value', 123, 'blue'])).toThrow())
+})
+
+describe('Array Property returns array', () => {
+   const prop = new ArrayProperty({ name: 'toto' })
+   test('transform array to string', () =>
+      expect(prop.set(arrayValue).get()).toBe(arrayValue))
+})
+
+// describe('Array Property supports registered transformer', () => {
+//    const prop = new ArrayProperty({ name: 'toto' })
+//    //prop.addTransformer(transformer)
+//    test('transform array to string', () =>
+//       expect(prop.set(arrayValue).get()).toBe('abcdef'))
+// })