@nu-art/ts-common 0.201.36 → 0.201.38

package/db/types.d.ts

@@ -1,4 +1,4 @@
-import { DB_Object, OmitDBObject, PartialProperties } from '../utils/types';
+import { DB_Object, OmitDBObject, SubsetObjectByKeys, UniqueId } from '../utils/types';
 import { ValidatorTypeResolver } from '../validator/validator-core';
 export type DBIndex<T extends DB_Object> = {
     id: string;
@@ -10,17 +10,45 @@ export type DBIndex<T extends DB_Object> = {
 };
 export type Default_UniqueKey = '_id';
 export type VersionType = string;
-export type DBProto<T extends DB_Object, Ks extends keyof T = Default_UniqueKey, Versions extends VersionType[] = ['1.0.0'], GeneratedKeys extends keyof T = keyof DB_Object> = {
-    generatedKeys: keyof DB_Object | GeneratedKeys;
-    uiType: PartialProperties<T, keyof DB_Object | GeneratedKeys>;
-    dbType: T;
-    uniqueKeys: Ks;
+export type VersionsDeclaration<T extends DB_Object, Versions extends VersionType[] = ['1.0.0'], Types extends [T, ...DB_Object[]] = [T, ...DB_Object[]]> = {
     versions: Versions;
-    validatorBE: ValidatorTypeResolver<OmitDBObject<T>>;
-    validatorFE: ValidatorTypeResolver<Omit<T, keyof GeneratedKeys>>;
-    dbIndices: DBIndex<T>;
+    types: Types;
+};
+export type Proto_DB_Object<T extends DB_Object, GeneratedKeys extends keyof T, Versions extends VersionsDeclaration<T, any, any>, UniqueKeys extends keyof T = Default_UniqueKey> = {
+    type: T;
+    generatedKeys: GeneratedKeys;
+    versions: Versions;
+    uniqueKeys: UniqueKeys;
+};
+export type DBProto<P extends Proto_DB_Object<any, any, any, any>, ModifiableSubType = Omit<P['type'], P['generatedKeys'] | keyof DB_Object>, GeneratedSubType = SubsetObjectByKeys<P['type'], P['generatedKeys']>> = {
+    uiType: ModifiableSubType & Partial<GeneratedSubType> & Partial<DB_Object>;
+    dbType: P['type'];
+    generatedPropsValidator: ValidatorTypeResolver<GeneratedSubType>;
+    modifiablePropsValidator: ValidatorTypeResolver<ModifiableSubType>;
+    uniqueKeys: P['uniqueKeys'][];
+    generatedProps: (P['generatedKeys'] | keyof DB_Object)[];
+    versions: P['versions']['versions'];
+    indices: DBIndex<P['type']>[];
+    uniqueParam: UniqueId | {
+        [K in P['uniqueKeys']]: P['type'][K];
+    };
+    metadata?: Metadata<OmitDBObject<P['type']>>;
+    lockKeys?: (keyof P['type'])[];
+};
+export type DBDef_V3<P 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'];
+    indices?: P['indices'];
+    lockKeys?: P['lockKeys'];
+    metadata?: P['metadata'];
 };
-export type DBDef_V2<Proto extends DBProto<any>> = DBDef<Proto['dbType'], Proto['uniqueKeys']>;
 /**
  * @field version - First item in the array is current version, Must pass all past versions with the current, default version is 1.0.0
  */
@@ -58,5 +86,36 @@ export type MetadataNested<T extends any> = T extends (infer I)[] ? MetadataProp
 export type Metadata<T extends any> = T extends (infer I)[] ? MetadataProperty<T> & {
     metadata: Metadata<I>;
 } : T extends object ? MetadataObject<T> : MetadataProperty<T>;
-export declare const DB_Object_Metadata: Metadata<DB_Object>;
+export declare const DB_Object_Metadata: {
+    _id: {
+        optional: boolean;
+        valueType: string;
+        description: string;
+    };
+    _v: {
+        optional: boolean;
+        valueType: string;
+        description: string;
+    };
+    _originDocId: {
+        optional: boolean;
+        valueType: string;
+        description: string;
+    };
+    __hardDelete: {
+        optional: boolean;
+        valueType: string;
+        description: string;
+    };
+    __created: {
+        optional: boolean;
+        valueType: string;
+        description: string;
+    };
+    __updated: {
+        optional: boolean;
+        valueType: string;
+        description: string;
+    };
+};
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nu-art/ts-common",
-  "version": "0.201.36",
+  "version": "0.201.38",
   "description": "js and ts infra",
   "keywords": [
     "TacB0sS",

package/utils/db-object-tools.d.ts

@@ -1,5 +1,8 @@
-import { DB_Object, OmitDBObject } from './types';
+import { DB_Object, OmitDBObject, SubsetObjectByKeys, TS_Object } from './types';
+import { DBProto } from '../db/types';
 export declare const KeysOfDB_Object: (keyof DB_Object)[];
 export declare function dbObjectToId(i: DB_Object): string;
+export declare function dbObjectToId_V3<Proto extends DBProto<any>>(i: Proto['dbType']): any;
 export declare function removeDBObjectKeys<T extends DB_Object>(instance: T): OmitDBObject<T>;
 export declare function keepDBObjectKeys<T extends DB_Object>(instance: T): DB_Object;
+export declare function keepPartialObject<T extends TS_Object, Ks extends keyof T>(instance: T, keys: Ks[]): SubsetObjectByKeys<T, Ks>;

package/utils/db-object-tools.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.keepDBObjectKeys = exports.removeDBObjectKeys = exports.dbObjectToId = exports.KeysOfDB_Object = void 0;
+exports.keepPartialObject = exports.keepDBObjectKeys = exports.removeDBObjectKeys = exports.dbObjectToId_V3 = 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'];
@@ -8,6 +8,10 @@ function dbObjectToId(i) {
     return i._id;
 }
 exports.dbObjectToId = dbObjectToId;
+function dbObjectToId_V3(i) {
+    return i._id;
+}
+exports.dbObjectToId_V3 = dbObjectToId_V3;
 function removeDBObjectKeys(instance) {
     const _instance = (0, object_tools_1.deepClone)(instance);
     exports.KeysOfDB_Object.forEach(key => delete _instance[key]);
@@ -15,10 +19,14 @@ function removeDBObjectKeys(instance) {
 }
 exports.removeDBObjectKeys = removeDBObjectKeys;
 function keepDBObjectKeys(instance) {
-    return exports.KeysOfDB_Object.reduce((objectToRet, key) => {
-        if ((0, tools_1.exists)(instance[key])) // @ts-ignore
+    return keepPartialObject(instance, exports.KeysOfDB_Object);
+}
+exports.keepDBObjectKeys = keepDBObjectKeys;
+function keepPartialObject(instance, keys) {
+    return keys.reduce((objectToRet, key) => {
+        if ((0, tools_1.exists)(instance[key]))
             objectToRet[key] = instance[key];
         return objectToRet;
     }, {});
 }
-exports.keepDBObjectKeys = keepDBObjectKeys;
+exports.keepPartialObject = keepPartialObject;

package/utils/types.d.ts

@@ -148,3 +148,56 @@ export type MergeTypes<T extends unknown[]> = T extends [a: infer A, ...rest: in
 export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
 export type NonEmptyArray<T> = [T, ...T[]];
 export type AssetValueType<T, K extends keyof T, Ex> = T[K] extends Ex ? K : never;
+/**
+ * Constructs a union of string paths representing the properties and nested properties of an object type.
+ *
+ * @typeParam ObjectType - The object type to analyze.
+ *
+ * @example
+ * // Simple Example: Analyzing a flat object
+ * type Person = { name: string; age: number };
+ * type PersonPaths = DotNotation<Person>; // 'name' | 'age'
+ *
+ * @example
+ * // Nested Example: Analyzing an object with nested properties
+ * type User = { name: string; address: { city: string; zip: string } };
+ * type UserPaths = DotNotation<User>; // 'name' | 'address' | 'address.city' | 'address.zip'
+ *
+ * @example
+ * // Complex Example: Analyzing an object with multiple levels of nesting
+ * type Profile = { name: string; contacts: { email: { primary: string; secondary: string } } };
+ * type ProfilePaths = DotNotation<Profile>; // 'name' | 'contacts' | 'contacts.email' | 'contacts.email.primary' | 'contacts.email.secondary'
+ */
+export type DotNotation<T> = T extends object ? {
+    [K in keyof T]: K extends string ? `${K & string}` | `${K & string}.${DotNotation<T[K]>}` : never;
+}[keyof T] : '';
+/**
+ * Replaces the type of nested property within an object, based on a specified path.
+ *
+ * @typeParam ObjectType - The original object type.
+ * @typeParam PropertyPath - The path to the property to replace, expressed as a dot-notation string.
+ * @typeParam NewValueType - The new type to replace the old type with.
+ *
+ * @example
+ * // Simple Example: Replace the 'age' property with a string
+ * type Person = { name: string; age: number };
+ * type NewPerson = ManipulateInnerPropValue<Person, 'age', string>;
+ * // Result: { name: string; age: string }
+ *
+ * @example
+ * // Nested Example: Replace the 'address.city' property with a number
+ * type User = { name: string; address: { city: string; zip: string } };
+ * type NewUser = ManipulateInnerPropValue<User, 'address.city', number>;
+ * // Result: { name: string; address: { city: number; zip: string } }
+ *
+ * @example
+ * // Complex Example: Replace the 'contacts.email.primary' property with a boolean
+ * type Profile = { name: string; contacts: { email: { primary: string; secondary: string } } };
+ * type NewProfile = ManipulateInnerPropValue<Profile, 'contacts.email.primary', boolean>;
+ * // Result: { name: string; contacts: { email: { primary: boolean; secondary: string } } }
+ */
+export type ManipulateInnerPropValue<ObjectType, PropertyPath extends DotNotation<ObjectType>, NewValueType> = PropertyPath extends `${infer Key}.${infer Rest}` ? Key extends keyof ObjectType ? {
+    [Prop in keyof ObjectType]: Prop extends Key ? Rest extends DotNotation<ObjectType[Key]> ? ManipulateInnerPropValue<ObjectType[Key], Rest, NewValueType> : never : ObjectType[Prop];
+} : never : {
+    [Prop in keyof ObjectType]: Prop extends PropertyPath ? NewValueType : ObjectType[Prop];
+};

package/validator/validators.d.ts

@@ -1,5 +1,5 @@
 import { Validator, ValidatorTypeResolver } from './validator-core';
-import { AuditableV2, DB_Object } from '../utils/types';
+import { AuditableV2 } from '../utils/types';
 export declare const tsValidate_OptionalArray: <T>(validator: ValidatorTypeResolver<T>) => Validator<T[]>;
 export declare const tsValidator_nonMandatoryString: Validator<string>;
 export declare const tsValidateMD5: (mandatory?: boolean) => Validator<string>;
@@ -25,4 +25,11 @@ export declare const tsValidator_LowerUpperStringWithSpaces: Validator<string>;
 export declare const tsValidator_LowerUpperStringWithDashesAndUnderscore: Validator<string>;
 export declare const tsValidator_InternationalPhoneNumber: Validator<string>;
 export declare const tsValidator_AuditableV2: ValidatorTypeResolver<AuditableV2>;
-export declare const DB_Object_validator: ValidatorTypeResolver<DB_Object>;
+export declare const DB_Object_validator: {
+    _id: Validator<string>;
+    _v: Validator<string>;
+    _originDocId: Validator<string>;
+    __hardDelete: Validator<boolean>;
+    __created: Validator<number>;
+    __updated: Validator<number>;
+};