@rtbnext/core 2.0.0-alpha.1

package/dist/model/Mover.js

@@ -0,0 +1,74 @@
+import { Snapshot } from '../abstract/Snapshot.js';
+import { Utils } from '../core/Utils.js';
+import { Parser } from '../parser/Parser.js';
+export class Mover extends Snapshot {
+  static instance;
+  constructor() {
+    super('mover');
+  }
+  // --- parse mover items ---
+  prepItems(items, method, dir) {
+    return items
+      .sort((a, b) => (dir === 'asc' ? a.value - b.value : b.value - a.value))
+      .slice(0, 10)
+      .map(({ uri, name, value }) => ({ uri, name, value: Parser[method](value) }));
+  }
+  parseEntry(entry, method) {
+    return { winner: this.prepItems(entry.winner, method, 'desc'), loser: this.prepItems(entry.loser, method, 'asc') };
+  }
+  parseBucket(bucket) {
+    return {
+      total: Parser.container({
+        value: { value: bucket.total.value, type: 'money' },
+        percent: { value: bucket.total.percent, type: 'pct' }
+      }),
+      networth: this.parseEntry(bucket.networth, 'money'),
+      percent: this.parseEntry(bucket.percent, 'pct')
+    };
+  }
+  // --- (override) save mover snapshot ---
+  saveSnapshot(snapshot, force) {
+    return super.saveSnapshot(
+      {
+        ...Utils.metaData(),
+        date: Parser.date(snapshot.date),
+        today: this.parseBucket(snapshot.today),
+        ytd: this.parseBucket(snapshot.ytd)
+      },
+      force
+    );
+  }
+  // --- instantiate ---
+  static getInstance() {
+    return (this.instance ??= new Mover());
+  }
+  // --- factory ---
+  static factory(date) {
+    return {
+      date: Parser.date(date ?? new Date(), 'ymd'),
+      today: {
+        total: { value: 0, percent: 0 },
+        networth: { winner: [], loser: [] },
+        percent: { winner: [], loser: [] }
+      },
+      ytd: { total: { value: 0, percent: 0 }, networth: { winner: [], loser: [] }, percent: { winner: [], loser: [] } }
+    };
+  }
+  // --- aggregate mover data ---
+  static aggregate(data, uri, name, mover, total = 0) {
+    if (data?.today?.value) {
+      const type = data.today.value > 0 ? 'winner' : 'loser';
+      mover.today.total.value += data.today.value;
+      mover.today.total.percent = total ? (mover.today.total.value / total) * 100 : 0;
+      mover.today.networth[type].push({ uri, name, value: data.today.value });
+      mover.today.percent[type].push({ uri, name, value: data.today.percent });
+    }
+    if (data?.ytd?.value) {
+      const type = data.ytd.value > 0 ? 'winner' : 'loser';
+      mover.ytd.total.value += data.ytd.value;
+      mover.ytd.total.percent = total ? (mover.ytd.total.value / total) * 100 : 0;
+      mover.ytd.networth[type].push({ uri, name, value: data.ytd.value });
+      mover.ytd.percent[type].push({ uri, name, value: data.ytd.percent });
+    }
+  }
+}

package/dist/model/Profile.d.ts

@@ -0,0 +1,49 @@
+import { ArrayMode } from '@komed3/deepmerge';
+import type {
+  TProfileData,
+  TProfileHistory,
+  TProfileHistoryItem,
+  TProfileIndexItem,
+  TProfileMetaData
+} from '@rtbnext/schema/src/model/profile';
+import type { IProfile } from '../interfaces/profile';
+export declare class Profile implements IProfile {
+  private static readonly storage;
+  private static readonly index;
+  private touched;
+  private uri;
+  private path;
+  private meta;
+  private data?;
+  private history?;
+  private constructor();
+  private resolvePath;
+  private metaData;
+  private resolveHistory;
+  getUri(): string;
+  getMeta(): TProfileMetaData['$metadata'];
+  schemaVersion(): number;
+  lastModified(): string;
+  lastModifiedTime(): number;
+  lastLookup(): string | undefined;
+  lastLookupTime(): number | undefined;
+  verify(id: string): boolean;
+  touch(): void;
+  touchLookup(): void;
+  needSave(): boolean;
+  save(syncIndex?: boolean): void;
+  getData(): TProfileData;
+  setData(data: TProfileData): void;
+  updateData(data: Partial<TProfileData>, mode?: ArrayMode): void;
+  getHistory(): TProfileHistory;
+  setHistory(history: TProfileHistory): void;
+  addHistory(row: TProfileHistoryItem): void;
+  mergeHistory(history: TProfileHistory): void;
+  move(uriLike: string, makeAlias?: boolean): boolean;
+  static factory(data?: Partial<TProfileData>): Partial<TProfileData>;
+  static get(uriLike: string): IProfile | false;
+  static getByItem(item: TProfileIndexItem): IProfile | false;
+  static find(uriLike: string): IProfile | false;
+  static create(uriLike: string, data: TProfileData, history?: TProfileHistory, lookup?: boolean): Profile | false;
+  static delete(uriLike: string): boolean;
+}

package/dist/model/Profile.js

@@ -0,0 +1,181 @@
+import { join } from 'node:path';
+import { log } from '../core/Logger.js';
+import { Storage } from '../core/Storage.js';
+import { Utils } from '../core/Utils.js';
+import { ProfileIndex } from './ProfileIndex.js';
+export class Profile {
+  static storage = Storage.getInstance();
+  static index = ProfileIndex.getInstance();
+  touched = false;
+  uri;
+  path;
+  meta;
+  data;
+  history;
+  constructor(item) {
+    if (!item || !item.uri) throw new Error('No valid profile index item given');
+    this.uri = item.uri;
+    this.path = join('profile', item.uri);
+    Profile.storage.ensurePath(this.path, true);
+    this.meta = this.metaData();
+  }
+  // --- helper ---
+  resolvePath(path) {
+    return join(this.path, path);
+  }
+  metaData() {
+    return Profile.storage.readJSON(this.resolvePath('meta.json')) || Utils.metaData();
+  }
+  resolveHistory(...history) {
+    return [...new Map([...this.getHistory(), ...history].map(i => [i[0], i])).values()].sort((a, b) =>
+      a[0].localeCompare(b[0])
+    );
+  }
+  // --- public getter ---
+  getUri() {
+    return this.uri;
+  }
+  getMeta() {
+    return this.meta.$metadata;
+  }
+  schemaVersion() {
+    return this.meta.$metadata.schemaVersion;
+  }
+  lastModified() {
+    return this.meta.$metadata.lastModified;
+  }
+  lastModifiedTime() {
+    return new Date(this.meta.$metadata.lastModified).getTime();
+  }
+  lastLookup() {
+    return this.meta.$metadata.lastLookup;
+  }
+  lastLookupTime() {
+    return this.meta.$metadata.lastLookup ? new Date(this.meta.$metadata.lastLookup).getTime() : undefined;
+  }
+  // --- verify profile ---
+  verify(id) {
+    return Utils.verifyHash(id, this.getData().id);
+  }
+  // --- work flow ---
+  touch() {
+    this.meta.$metadata.lastModified = Utils.date('iso');
+    this.touched = true;
+  }
+  touchLookup() {
+    this.touch();
+    this.meta.$metadata.lastLookup = this.meta.$metadata.lastModified;
+  }
+  needSave() {
+    return this.touched;
+  }
+  save(syncIndex = true) {
+    if (!this.touched) return;
+    log.debug(`Saving profile: ${this.uri}`);
+    log.catch(() => {
+      if (syncIndex && this.data && !Profile.index.syncFromData(this.data))
+        throw new Error('Failed to update profile index');
+      if (this.data && !Profile.storage.writeJSON(this.resolvePath('profile.json'), this.data))
+        throw new Error('Failed to write profile data');
+      if (this.history && !Profile.storage.writeCSV(this.resolvePath('history.csv'), this.history))
+        throw new Error('Failed to write profile history');
+      if (this.meta && !Profile.storage.writeJSON(this.resolvePath('meta.json'), this.meta))
+        throw new Error('Failed to write profile metadata');
+      this.touched = false;
+    }, `Failed to save profile: ${this.uri}`);
+  }
+  // --- profile data ---
+  getData() {
+    return (this.data ??= Profile.storage.readJSON(this.resolvePath('profile.json')) ?? Profile.factory());
+  }
+  setData(data) {
+    this.data = Profile.factory(data);
+    this.touch();
+  }
+  updateData(data, mode = 'replace' /* ArrayMode.Replace */) {
+    this.data = Utils.merge(mode, this.getData(), data);
+    this.touch();
+  }
+  // --- profile history ---
+  getHistory() {
+    return (this.history ??= Profile.storage.readCSV(this.resolvePath('history.csv')) ?? []);
+  }
+  setHistory(history) {
+    this.history = history;
+    this.touch();
+  }
+  addHistory(row) {
+    this.setHistory(this.resolveHistory(row));
+  }
+  mergeHistory(history) {
+    this.setHistory(this.resolveHistory(...history));
+  }
+  // --- move profile ---
+  move(uriLike, makeAlias = true) {
+    const uri = Utils.sanitize(uriLike);
+    log.debug(`Moving profile: ${this.uri} -> ${uri}`);
+    return (
+      log.catch(() => {
+        const item = Profile.index.move(this.uri, uri, makeAlias);
+        if (!item) throw new Error('Failed to move profile index item');
+        const oldPath = this.path;
+        this.uri = uri;
+        this.path = join('profile', uri);
+        if (!Profile.storage.move(oldPath, this.path)) throw new Error('Failed to move profile storage');
+        this.updateData({ uri: uri });
+        this.save(false);
+        return true;
+      }, `Failed to move profile: ${this.uri} -> ${uri}`) ?? false
+    );
+  }
+  // --- factory ---
+  static factory(data) {
+    return { ...{ info: {}, bio: {}, related: [], media: [], ranking: [], annual: [], assets: [] }, ...data };
+  }
+  // --- instantiate ---
+  static get(uriLike) {
+    return log.catch(() => new Profile(Profile.index.get(uriLike)), `Failed to get profile: ${uriLike}`) ?? false;
+  }
+  static getByItem(item) {
+    return log.catch(() => new Profile(item), `Failed to get profile by item: ${item.uri}`) ?? false;
+  }
+  static find(uriLike) {
+    return (
+      log.catch(
+        () => new Profile(Profile.index.find(uriLike).values().next().value),
+        `Failed to find profile: ${uriLike}`
+      ) ?? false
+    );
+  }
+  // --- create profile ---
+  static create(uriLike, data, history, lookup = false) {
+    const uri = Utils.sanitize(uriLike);
+    log.debug(`Creating profile: ${uri}`);
+    return (
+      log.catch(() => {
+        if (!Profile.index.isAliasAvailable(uri)) throw new Error(`Profile URI ${uri} is already taken`);
+        const profile = new Profile({ uri });
+        profile.setData(Profile.factory(data));
+        profile.setHistory(history ?? []);
+        if (lookup) profile.touchLookup();
+        profile.save();
+        log.debug(`Profile created: ${uri}`);
+        return profile;
+      }, `Failed to create profile: ${uri}`) ?? false
+    );
+  }
+  // --- delete profile ---
+  static delete(uriLike) {
+    const uri = Utils.sanitize(uriLike);
+    log.debug(`Deleting profile: ${uri}`);
+    return (
+      log.catch(() => {
+        const path = join('profile', uri);
+        if (!Profile.storage.remove(path)) throw new Error('Failed to remove profile from storage');
+        Profile.index.delete(uri);
+        log.debug(`Profile deleted: ${uri}`);
+        return true;
+      }, `Failed to delete profile: ${uri}`) ?? false
+    );
+  }
+}

package/dist/model/ProfileIndex.d.ts

@@ -0,0 +1,20 @@
+import type { TProfileData, TProfileIndex, TProfileIndexItem } from '@rtbnext/schema/src/model/profile';
+import { Index } from '../abstract/Index.js';
+import type { IProfileIndex } from '../interfaces/index';
+export declare class ProfileIndex extends Index<TProfileIndexItem, TProfileIndex> implements IProfileIndex {
+  protected static instance: IProfileIndex;
+  private constructor();
+  private sanitizeAliases;
+  private getUriByAlias;
+  private assertAvailableAlias;
+  private resolveAliases;
+  find(uriLike: string): TProfileIndex;
+  move(from: string, to: string, makeAlias?: boolean): TProfileIndexItem | false;
+  syncFromData(data: TProfileData): TProfileIndexItem | false;
+  hasAlias(aliasLike: string, uriLike?: string): string | false;
+  isAliasAvailable(aliasLike: string): boolean;
+  removeAlias(aliasLike: string): boolean;
+  addAliases(uriLike: string, ...aliases: string[]): TProfileIndexItem | false;
+  rmvAliases(uriLike: string, ...aliases: string[]): TProfileIndexItem | false;
+  static getInstance(): IProfileIndex;
+}

package/dist/model/ProfileIndex.js

@@ -0,0 +1,140 @@
+import { Index } from '../abstract/Index.js';
+import { log } from '../core/Logger.js';
+import { Utils } from '../core/Utils.js';
+export class ProfileIndex extends Index {
+  static instance;
+  constructor() {
+    super('profile', 'profile/index.json');
+  }
+  // --- alias helper ---
+  sanitizeAliases(aliases) {
+    return aliases.map(a => Utils.sanitize(a)).filter(Boolean);
+  }
+  getUriByAlias(alias) {
+    return [...this.index.values()].find(({ aliases }) => aliases.includes(alias))?.uri || false;
+  }
+  assertAvailableAlias(alias, whitelist = []) {
+    if (this.has(alias)) throw new Error(`Alias ${alias} conflicts with existing profile URI`);
+    const owner = this.getUriByAlias(alias);
+    if (owner && !whitelist.includes(owner)) throw new Error(`Alias ${alias} already exists for profile ${owner}`);
+  }
+  resolveAliases(uri, aliases = [], add = [], rmv = []) {
+    for (const a of add) this.assertAvailableAlias(a, [uri]);
+    return Utils.mergeArray(
+      aliases.filter(alias => !rmv.includes(alias)),
+      add,
+      'unique' /* ArrayMode.Unique */
+    );
+  }
+  // --- special profile index operations ---
+  find(uriLike) {
+    const uri = Utils.sanitize(uriLike);
+    return new Map([...this.index].filter(([key, { aliases }]) => key === uri || aliases.includes(uri)));
+  }
+  move(from, to, makeAlias = true) {
+    log.debug(`Moving profile index item from ${from} to ${to}`);
+    return (
+      log.catch(() => {
+        ((from = Utils.sanitize(from)), (to = Utils.sanitize(to)));
+        const target = this.index.get(from),
+          match = this.find(to);
+        if (!target || match.size > 1) throw new Error('Invalid move operation');
+        const foundKey = match.keys().next().value;
+        if (foundKey && foundKey !== from) throw new Error('Destination already exists');
+        const item = {
+          ...target,
+          uri: to,
+          aliases: this.resolveAliases(to, target.aliases, makeAlias ? [from] : [], [to])
+        };
+        this.index.delete(from);
+        this.index.set(to, item);
+        this.saveIndex();
+        return item;
+      }, `Failed to move profile index item ${from} to ${to}`) ?? false
+    );
+  }
+  syncFromData(data) {
+    const {
+      uri,
+      info: {
+        name: { shortName: name }
+      },
+      bio: { cv },
+      wiki: { desc, image } = {}
+    } = data;
+    const item = this.get(uri);
+    return this.update(uri, {
+      ...item,
+      uri,
+      name,
+      desc,
+      image: image?.thumb ?? image?.file,
+      aliases: this.resolveAliases(uri, item?.aliases),
+      text: Utils.buildSearchText(cv)
+    });
+  }
+  // --- alias handling ---
+  hasAlias(aliasLike, uriLike) {
+    const owner = this.getUriByAlias(Utils.sanitize(aliasLike));
+    if (uriLike !== undefined && owner !== Utils.sanitize(uriLike)) return false;
+    return owner;
+  }
+  isAliasAvailable(aliasLike) {
+    try {
+      this.assertAvailableAlias(Utils.sanitize(aliasLike));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  removeAlias(aliasLike) {
+    const alias = Utils.sanitize(aliasLike);
+    log.debug(`Removing profile alias ${alias}`);
+    return (
+      log.catch(() => {
+        for (const item of this.index.values()) {
+          const index = item.aliases.indexOf(alias);
+          if (index >= 0) {
+            item.aliases.splice(index, 1);
+            this.saveIndex();
+            log.debug(`Removed alias ${alias} from profile index item ${item.uri}`);
+            return true;
+          }
+        }
+        return false;
+      }, `Failed to remove profile alias ${alias}`) ?? false
+    );
+  }
+  addAliases(uriLike, ...aliases) {
+    const uri = Utils.sanitize(uriLike);
+    log.debug(`Adding profile aliases [${aliases.join(', ')}] to ${uri}`);
+    return (
+      log.catch(() => {
+        const item = this.index.get(uri);
+        if (!item) throw new Error(`Profile index item ${uri} not found`);
+        if (!aliases.length) return item;
+        item.aliases = this.resolveAliases(uri, item.aliases, this.sanitizeAliases(aliases));
+        this.saveIndex();
+        return item;
+      }, `Failed to add profile aliases to ${uri}`) ?? false
+    );
+  }
+  rmvAliases(uriLike, ...aliases) {
+    const uri = Utils.sanitize(uriLike);
+    log.debug(`Removing profile aliases [${aliases.join(', ')}] from ${uri}`);
+    return (
+      log.catch(() => {
+        const item = this.index.get(uri);
+        if (!item) throw new Error(`Profile index item ${uri} not found`);
+        if (!aliases.length) return item;
+        item.aliases = this.resolveAliases(uri, item.aliases, [], this.sanitizeAliases(aliases));
+        this.saveIndex();
+        return item;
+      }, `Failed to remove profile aliases from ${uri}`) ?? false
+    );
+  }
+  // --- instantitate ---
+  static getInstance() {
+    return (ProfileIndex.instance ??= new ProfileIndex());
+  }
+}

package/dist/model/Stats.d.ts

@@ -0,0 +1,56 @@
+import type { TStatsGroup as TStatsGroupType } from '@rtbnext/schema/src/base/const';
+import type { TListSnapshot, TPersonListItem } from '@rtbnext/schema/src/model/list';
+import type { TProfileData } from '@rtbnext/schema/src/model/profile';
+import type {
+  TDBStats,
+  TDBStatsData,
+  TGlobalStats,
+  TGlobalStatsData,
+  THistory,
+  TProfileStats,
+  TProfileStatsData,
+  TScatter,
+  TScatterItem,
+  TStatsGroup,
+  TStatsGroupItem,
+  TTop10,
+  TTop10Data,
+  TTop10List,
+  TWealthStats,
+  TWealthStatsData
+} from '@rtbnext/schema/src/model/stats';
+import type { IStats } from '../interfaces/stats';
+export declare class Stats implements IStats {
+  private static readonly storage;
+  private static instance;
+  private constructor();
+  private initDB;
+  private resolvePath;
+  private prepStats;
+  private getStats;
+  private saveStats;
+  getGlobalStats(): TGlobalStats;
+  getProfileStats(): TProfileStats;
+  getWealthStats(): TWealthStats;
+  getScatter(): TScatter;
+  getTop10(): TTop10;
+  getDBStats(): TDBStats;
+  getHistory(): THistory;
+  getGroupedStatsIndex(group: TStatsGroupType): TStatsGroup<string>['index'];
+  getGroupedStatsHistory(group: TStatsGroupType, key: string): THistory;
+  getGroupedStats(group: TStatsGroupType): TStatsGroup<string>;
+  setGlobalStats(data: TGlobalStatsData): boolean;
+  setProfileStats(data: TProfileStatsData): boolean;
+  setWealthStats(data: TWealthStatsData): boolean;
+  setScatter(items: TScatterItem[]): boolean;
+  setTop10(data: TTop10Data): boolean;
+  updateTop10(key: string, list: TTop10List): boolean;
+  setDBStats(data: TDBStatsData): boolean;
+  setGroupedStats<T extends string = string>(group: TStatsGroupType, raw: Record<T, TStatsGroupItem>): boolean;
+  updateHistory(data: Partial<TGlobalStats>): boolean;
+  generateWealthStats(scatter: TScatterItem[]): boolean;
+  generateTop10Entry(snapshot: TListSnapshot<TPersonListItem>): boolean;
+  generateDBStats(): boolean;
+  static getInstance(): IStats;
+  static aggregate(data: TProfileData, date: string, stats: any): void;
+}