@nu-art/ts-common 0.202.74 → 0.202.76

package/db/types.d.ts

@@ -25,6 +25,15 @@ export type InnerDependencies<T extends DB_Object, K extends SubsetKeys<keyof T,
 type Exact<T, Shape> = T & {
     [K in Exclude<keyof Shape, keyof T>]?: never;
 };
+/**
+ * Defines the base structure and constraints for a database object.
+ *
+ * @template T The base type of the database object.
+ * @template GeneratedKeys Keys that are auto-generated and should not be manually modified.
+ * @template Versions Versioning information for the database object.
+ * @template UniqueKeys Keys that are unique to each instance of the database object.
+ * @template Dependencies (Future Use) Defines dependencies or relationships to other database objects.
+ */
 export type Proto_DB_Object<T extends DB_Object, GeneratedKeys extends keyof T | never, Versions extends VersionsDeclaration<VersionType[]>, UniqueKeys extends keyof T = Default_UniqueKey, Dependencies extends Exact<{
     [K in SubsetKeys<keyof T, T, string | string[]>]?: DBProto<any>;
 }, Dependencies> = never> = {
@@ -34,6 +43,13 @@ export type Proto_DB_Object<T extends DB_Object, GeneratedKeys extends keyof T |
     uniqueKeys: UniqueKeys;
     dependencies: Dependencies;
 };
+/**
+ * Extends Proto_DB_Object with additional UI and validation details.
+ *
+ * @template P The Proto_DB_Object this DBProto is based on.
+ * @template ModifiableSubType The subset of P's type that is modifiable.
+ * @template GeneratedSubType The subset of P's type that is auto-generated.
+ */
 export type DBProto<P extends Proto_DB_Object<any, any, VersionsDeclaration<VersionType[]>, any, any>, ModifiableSubType = Omit<P['type'], P['generatedKeys'] | keyof DB_Object>, GeneratedSubType = SubsetObjectByKeys<P['type'], P['generatedKeys']>> = {
     uiType: ModifiableSubType & Partial<GeneratedSubType> & Partial<DB_Object>;
     preDbType: ModifiableSubType & Partial<GeneratedSubType>;
@@ -50,19 +66,24 @@ export type DBProto<P extends Proto_DB_Object<any, any, VersionsDeclaration<Vers
     metadata?: Metadata<OmitDBObject<P['type']>>;
     lockKeys?: (keyof P['type'])[];
 };
-export type DBDef_V3<P extends DBProto<any, any, any>> = {
+/**
+ * Represents the definition of a database entity with metadata and validation rules.
+ *
+ * @template Proto The DBProto type that this definition is based on.
+ */
+export type DBDef_V3<Proto extends DBProto<any, any, any>> = {
     dbName: string;
     entityName: string;
     TTL?: number;
     lastUpdatedTTL?: number;
     upgradeChunksSize?: number;
-    generatedPropsValidator: P['generatedPropsValidator'];
-    modifiablePropsValidator: P['modifiablePropsValidator'];
-    uniqueKeys?: P['uniqueKeys'];
-    versions?: P['versions']['versions'];
-    indices?: P['indices'];
-    lockKeys?: P['lockKeys'];
-    metadata?: P['metadata'];
+    generatedPropsValidator: Proto['generatedPropsValidator'];
+    modifiablePropsValidator: Proto['modifiablePropsValidator'];
+    uniqueKeys?: Proto['uniqueKeys'];
+    versions?: Proto['versions']['versions'];
+    indices?: Proto['indices'];
+    lockKeys?: Proto['lockKeys'];
+    metadata?: Proto['metadata'];
 };
 /**
  * @field version - First item in the array is current version, Must pass all past versions with the current, default version is 1.0.0

package/mem-storage/MemStorage.d.ts

@@ -13,6 +13,7 @@ export declare class MemKey<T> {
     constructor(key: string, unique?: boolean);
     setResolver: (resolver?: ((storage: MemStorage) => T) | undefined) => this;
     resolve: (storage: MemStorage) => Promise<void>;
+    assert: (value?: T) => T;
     get: (value?: T) => T;
     set: (value: T) => T;
     merge: (value: T) => any;

package/mem-storage/MemStorage.js

@@ -14,6 +14,7 @@ const tools_1 = require("../utils/tools");
 const exceptions_1 = require("../core/exceptions/exceptions");
 const async_hooks_1 = require("async_hooks");
 const random_tools_1 = require("../utils/random-tools");
+const validator_core_1 = require("../validator/validator-core");
 const asyncLocalStorage = new async_hooks_1.AsyncLocalStorage();
 class MemStorage {
     constructor() {
@@ -59,6 +60,15 @@ class MemKey {
                 return;
             this.set(value);
         });
+        this.assert = (value) => {
+            const storedValue = this.get();
+            if (!(0, tools_1.exists)(value))
+                return storedValue;
+            if (value !== storedValue) {
+                throw new validator_core_1.ValidationException(`Asserting MemKey(${this.key}) ${value} !== ${storedValue}!`);
+            }
+            return storedValue;
+        };
         this.get = (value) => {
             // @ts-ignore
             const memValue = asyncLocalStorage.getStore().get(this, value);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nu-art/ts-common",
-  "version": "0.202.74",
+  "version": "0.202.76",
   "description": "js and ts infra",
   "keywords": [
     "TacB0sS",
@@ -34,7 +34,7 @@
   "dependencies": {
     "fast-csv": "^4.3.6",
     "export-to-csv": "0.2.1",
-    "moment": "^2.24.0",
+    "moment": "^2.29.4",
     "node-forge": "^1.2.1",
     "uuid": "^9.0.0",
     "csv-parser": "^2.3.3"

package/utils/db-object-tools.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.keepPartialObject = exports.keepDBObjectKeys = exports.deleteKeysObject = exports.removeDBObjectKeys = exports.dbObjectToId = exports.KeysOfDB_Object = void 0;
 const object_tools_1 = require("./object-tools");
 const tools_1 = require("./tools");
-exports.KeysOfDB_Object = ['_id', '_v', '__created', '__updated'];
+exports.KeysOfDB_Object = ['_id', '_v', '__created', '__updated', '__metadata1'];
 function dbObjectToId(i) {
     return i._id;
 }

package/utils/types.d.ts

@@ -95,11 +95,12 @@ export type DB_BaseObject = {
     _id: string;
 };
 export type DB_Object = DB_BaseObject & {
-    _v?: string;
-    _originDocId?: UniqueId;
+    __metadata1?: any;
     __hardDelete?: boolean;
     __created: number;
     __updated: number;
+    _v?: string;
+    _originDocId?: UniqueId;
 };
 export type UniqueId = string;
 export type PreDB<T extends DB_Object, K extends keyof T = never> = PartialProperties<T, keyof DB_Object | K>;
@@ -151,6 +152,9 @@ export type AssetValueType<T, K extends keyof T, Ex> = T[K] extends Ex ? K : nev
 export type RecursiveOmit<T, OmitKey extends keyof any> = {
     [K in Exclude<keyof T, OmitKey>]: T[K] extends object ? RecursiveOmit<T[K], OmitKey> : T[K];
 };
+export type RecursivePartial<T> = {
+    [P in keyof T]?: T[P] extends any[] ? T[P] : T[P] extends object ? RecursivePartial<T[P]> : T[P];
+};
 /**
  * Constructs a union of string paths representing the properties and nested properties of an object type.
  *

package/validator/type-validators.d.ts

@@ -10,7 +10,7 @@ type validatorObject<T> = {
 };
 export declare const tsValidateUnionV3: <T extends unknown>(validatorObject: validatorObject<T>, mandatory?: boolean) => ((input?: T | undefined) => any)[];
 export declare const tsValidateArray: <T extends any[], I extends ArrayType<T> = ArrayType<T>>(validator: ValidatorTypeResolver<I>, mandatory?: boolean, minimumLength?: number) => Validator<I[]>;
-export declare const tsValidateString: (length?: number, mandatory?: boolean) => Validator<string>;
+export declare const tsValidateString: (length?: number | [number, number], mandatory?: boolean) => Validator<string>;
 export declare const tsValidateStringMinLength: (length: number, mandatory?: boolean) => Validator<string>;
 export declare const tsValidateNumber: (mandatory?: boolean) => Validator<number>;
 export declare const tsValidateEnum: (enumType: TypedMap<number | string>, mandatory?: boolean) => Validator<number | string>;

package/validator/type-validators.js

@@ -79,9 +79,15 @@ const tsValidateString = (length = -1, mandatory = true) => {
                 return `input is not a string`;
             if (length === -1)
                 return;
-            if (input.length <= length)
-                return;
-            return `input is longer than ${length}`;
+            if (Array.isArray(length)) {
+                if (length[0] > input.length)
+                    return `input length is lesser than ${length}`;
+                if (input.length > length[1])
+                    return `input length is longer than ${length}`;
+            }
+            else if (input.length > length)
+                return `input length is longer than ${length}`;
+            return;
         }];
 };
 exports.tsValidateString = tsValidateString;

package/validator/validators.d.ts

@@ -27,6 +27,7 @@ export declare const tsValidator_LowerUpperStringWithDashesAndUnderscore: Valida
 export declare const tsValidator_InternationalPhoneNumber: Validator<string>;
 export declare const tsValidator_AuditableV2: ValidatorTypeResolver<AuditableV2>;
 export declare const DB_Object_validator: {
+    __metadata1: import("./validator-core").ValidatorImpl<any>;
     _id: Validator<string>;
     _v: Validator<string>;
     _originDocId: Validator<string>;

package/validator/validators.js

@@ -37,6 +37,8 @@ exports.tsValidator_LowerUpperStringWithDashesAndUnderscore = (0, type_validator
 exports.tsValidator_InternationalPhoneNumber = (0, type_validators_1.tsValidateRegexp)(/^\+(?:[0-9] ?){6,14}[0-9]$/);
 exports.tsValidator_AuditableV2 = { _auditorId: (0, type_validators_1.tsValidateString)() };
 exports.DB_Object_validator = {
+    // this will be the way to handle app level context via proto.. need to rename this to __metadata once done
+    __metadata1: exports.tsValidateOptional,
     _id: exports.tsValidateUniqueId,
     _v: exports.tsValidateVersion,
     _originDocId: exports.tsValidateOptionalId,