@privateaim/server-kit 0.8.13 → 0.8.15

package/src/services/log-store/entities/memory.ts

@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 2025.
+ *  Author Peter Placzek (tada5hi)
+ *  For the full copyright and license information,
+ *  view the LICENSE file that was distributed with this source code.
+ */
+
+import type { Log } from '@privateaim/kit';
+import { LogLevel } from '@privateaim/kit';
+import type {
+    LogInput, LogStore, LogStoreQueryOptions,
+} from '../types';
+import { nanoSeconds } from '../../loki';
+import { BaseLogStore } from './base';
+
+export class MemoryLogStore extends BaseLogStore implements LogStore {
+    public readonly items : Log[];
+
+    constructor(labels?: Record<string, string>) {
+        super();
+
+        this.items = [];
+        this.labels = labels;
+    }
+
+    // todo: apply query options
+    async delete(): Promise<void> {
+        return Promise.resolve();
+    }
+
+    async query(options: LogStoreQueryOptions = {}): Promise<[Log[], number]> {
+        // todo: apply all query options
+
+        const data = this.items.filter((item) => {
+            if (options.labels) {
+                if (!item.labels) {
+                    return false;
+                }
+
+                const labelKeys = Object.keys(options.labels);
+                for (let i = 0; i < labelKeys.length; i++) {
+                    if (!item.labels[labelKeys[i]]) {
+                        return false;
+                    }
+
+                    if (item.labels[labelKeys[i]] !== options.labels[labelKeys[i]]) {
+                        return false;
+                    }
+                }
+            }
+
+            return true;
+        });
+
+        return [
+            data,
+            data.length,
+        ];
+    }
+
+    async write(message: string | LogInput, labels?: Record<string, string>): Promise<Log> {
+        let data : Log;
+
+        if (typeof message === 'string') {
+            const labelsNormalized = {
+                ...this.labels,
+                ...(labels || {}),
+            };
+            const level = (labelsNormalized.level || LogLevel.DEBUG) as LogLevel;
+            delete labelsNormalized.level;
+
+            data = {
+                message,
+                level,
+                time: nanoSeconds(),
+                labels: labelsNormalized,
+            };
+        } else {
+            const labelsNormalized = {
+                ...this.labels,
+                ...(message.labels || {}),
+                ...(labels || {}),
+            };
+
+            const level = (message.level || labelsNormalized.level || LogLevel.DEBUG) as LogLevel;
+            delete labelsNormalized.level;
+
+            data = {
+                ...message,
+                level,
+                time: message.time || nanoSeconds(),
+                labels: labelsNormalized,
+            };
+        }
+
+        this.items.push(data);
+
+        return data;
+    }
+}

package/src/services/log-store/index.ts

@@ -0,0 +1,10 @@
+/*
+ * Copyright (c) 2025.
+ *  Author Peter Placzek (tada5hi)
+ *  For the full copyright and license information,
+ *  view the LICENSE file that was distributed with this source code.
+ */
+
+export * from './entities';
+export * from './singleton';
+export * from './types';

package/src/services/log-store/singleton.ts

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2024.
+ * Author Peter Placzek (tada5hi)
+ * For the full copyright and license information,
+ * view the LICENSE file that was distributed with this source code.
+ */
+
+import type { Factory } from 'singa';
+import { singa } from 'singa';
+import type { LogStore } from './types';
+import { LokiLogStore, MemoryLogStore } from './entities';
+import { isLokiClientUsable, useLokiClient } from '../loki';
+
+const instance = singa<LogStore>({
+    name: 'logStore',
+    factory: () => {
+        if (isLokiClientUsable()) {
+            const loki = useLokiClient();
+            return new LokiLogStore(loki);
+        }
+
+        return new MemoryLogStore();
+    },
+});
+
+export function isLogStoreUsable() {
+    return instance.has() || instance.hasFactory();
+}
+
+export function setLogStoreFactory(input: Factory<LogStore>) {
+    instance.setFactory(input);
+}
+
+export function useLogStore(): LogStore {
+    return instance.use();
+}

package/src/services/log-store/types.ts

@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2025.
+ *  Author Peter Placzek (tada5hi)
+ *  For the full copyright and license information,
+ *  view the LICENSE file that was distributed with this source code.
+ */
+
+import type { Log, LogLevel } from '@privateaim/kit';
+
+export type LogStoreQueryOptions = {
+    labels?: Record<string, string>
+    start?: number,
+    end?: number,
+    sort?: 'DESC' | 'ASC',
+    limit?: number
+};
+
+export type LogStoreDeleteOptions = {
+    labels?: Record<string, string>
+    start?: number,
+    end?: number,
+};
+
+export type LogInput = Omit<Log, 'labels' | 'time' | 'level'> & {
+    time?: bigint,
+    level?: `${LogLevel}`,
+    labels?: Record<string, string>
+};
+
+export interface LogStore {
+    setLabels(labels: Record<string, string>): void;
+
+    getLabels() : Record<string, string>;
+
+    extendLabels(labels: Record<string, string>): void;
+
+    write(message: string | LogInput, labels?: Record<string, string>) : Promise<Log>;
+
+    query(options?: LogStoreQueryOptions) : Promise<[Log[], number]>;
+
+    delete(options?: LogStoreDeleteOptions) : Promise<void>;
+}

package/src/services/logger/module.ts

@@ -11,9 +11,11 @@ import { EnvironmentName } from 'typeorm-extension';
 import type { Logger } from 'winston';
 import { createLogger as create, format, transports } from 'winston';
 import type { LoggerCreateContext, LoggerTransports } from './types';
+import { LogStoreTransport } from './store';
+import { useLogStore } from '../log-store';
 
 export function createLogger(ctx: LoggerCreateContext = {}) : Logger {
-    const { directory, options = {} } = ctx;
+    const store = ctx.store || useLogStore();
 
     let loggerTransports : LoggerTransports;
     if (read('env') === EnvironmentName.PRODUCTION) {
@@ -22,23 +24,37 @@ export function createLogger(ctx: LoggerCreateContext = {}) : Logger {
                 level: 'info',
             }),
             new transports.File({
-                filename: path.join(directory || process.cwd(), 'access.log'),
+                filename: path.join(ctx.directory || process.cwd(), 'access.log'),
                 level: 'http',
                 maxsize: 10 * 1024 * 1024, // 10MB
                 maxFiles: 5,
             }),
             new transports.File({
-                filename: path.join(directory || process.cwd(), 'error.log'),
+                filename: path.join(ctx.directory || process.cwd(), 'error.log'),
                 level: 'warn',
                 maxsize: 10 * 1024 * 1024, // 10MB
                 maxFiles: 5,
             }),
+            new LogStoreTransport(
+                store,
+                {
+                    level: 'http',
+                    labels: ctx.labels,
+                },
+            ),
         ];
     } else {
         loggerTransports = [
             new transports.Console({
                 level: 'debug',
             }),
+            new LogStoreTransport(
+                store,
+                {
+                    level: 'http',
+                    labels: ctx.labels,
+                },
+            ),
         ];
     }
 
@@ -46,12 +62,11 @@ export function createLogger(ctx: LoggerCreateContext = {}) : Logger {
         format: format.combine(
             format.errors({ stack: true }),
             format.timestamp(),
-            format.colorize(),
             format.simple(),
         ),
         level: 'debug',
         transports: loggerTransports,
         // todo: deeply merge options
-        ...(options || {}),
+        ...(ctx.options || {}),
     });
 }

package/src/services/logger/store.ts

@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2025.
+ *  Author Peter Placzek (tada5hi)
+ *  For the full copyright and license information,
+ *  view the LICENSE file that was distributed with this source code.
+ */
+
+import type { TransportStreamOptions } from 'winston-transport';
+import WinstonTransport from 'winston-transport';
+import type { LogInput, LogStore } from '../log-store';
+
+type LogStoreTransportOptions = TransportStreamOptions & {
+    labels?: Record<string, string>
+};
+
+export class LogStoreTransport extends WinstonTransport {
+    protected instance : LogStore;
+
+    protected labels : Record<string, string>;
+
+    constructor(store: LogStore, options: LogStoreTransportOptions = {}) {
+        super(options);
+
+        this.instance = store;
+        this.labels = options.labels || {};
+    }
+
+    log(info: Record<PropertyKey, any>, next: () => void): any {
+        const {
+            message, timestamp, stack, ...data
+        } = info;
+
+        const labels : Record<string, string> = {
+            ...this.labels,
+        };
+        const keys = Object.keys(data);
+        for (let i = 0; i < keys.length; i++) {
+            if (typeof keys[i] !== 'string') {
+                continue;
+            }
+
+            const value = data[keys[i]];
+
+            if (
+                typeof value === 'string' ||
+                typeof value === 'number' ||
+                typeof value === 'boolean'
+            ) {
+                labels[keys[i]] = `${value}`;
+            }
+        }
+
+        let date : Date;
+        if (typeof timestamp === 'string') {
+            date = new Date(`${timestamp}`);
+        } else {
+            date = new Date();
+        }
+
+        const payload : LogInput = {
+            message: stack || message,
+            time: BigInt(date.getTime()) * 1_000_000n,
+            labels,
+        };
+
+        Promise.resolve()
+            .then(() => this.instance.write(payload))
+            .then(() => next());
+    }
+}

package/src/services/logger/types.ts

@@ -6,10 +6,13 @@
  */
 
 import type { Logger, LoggerOptions } from 'winston';
+import type { LogStore } from '../log-store';
 
 export type LoggerCreateContext = {
     directory?: string,
-    options?: Partial<LoggerOptions>
+    options?: Partial<LoggerOptions>,
+    store?: LogStore,
+    labels?: Record<string, string>,
 };
 
 export type LoggerTransports = LoggerOptions['transports'];

package/src/services/loki/index.ts

@@ -0,0 +1,9 @@
+/*
+ * Copyright (c) 2024.
+ * Author Peter Placzek (tada5hi)
+ * For the full copyright and license information,
+ * view the LICENSE file that was distributed with this source code.
+ */
+
+export * from './module';
+export * from './singleton';

package/src/services/loki/module.ts

@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2024.
+ * Author Peter Placzek (tada5hi)
+ * For the full copyright and license information,
+ * view the LICENSE file that was distributed with this source code.
+ */
+
+import {
+    LokiClient,
+    CompactorDeletionRequestCreate as LokiCompactorDeletionRequestCreate,
+    Config as LokiConfig,
+    ConfigInput as LokiConfigInput,
+    DistributorPushStream as LokiDistributorPushStream,
+    QuerierQueryRangeOptions as LokiQuerierQueryRangeOptions,
+    QuerierQueryResult as LokiQuerierQueryResult,
+    createClient as createLokiClient,
+    nanoSeconds,
+} from '@hapic/loki';
+
+export {
+    LokiClient,
+    LokiConfig,
+    LokiConfigInput,
+    LokiCompactorDeletionRequestCreate,
+    LokiDistributorPushStream,
+    LokiQuerierQueryRangeOptions,
+    LokiQuerierQueryResult,
+    createLokiClient,
+    nanoSeconds,
+};

package/src/services/loki/singleton.ts

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2024.
+ * Author Peter Placzek (tada5hi)
+ * For the full copyright and license information,
+ * view the LICENSE file that was distributed with this source code.
+ */
+
+import type { Factory } from 'singa';
+import { singa } from 'singa';
+import type { LokiClient } from '@hapic/loki';
+
+const instance = singa<LokiClient>({
+    name: 'loki',
+});
+
+export function setLokiFactory(factory: Factory<LokiClient>) {
+    instance.setFactory(factory);
+}
+
+export function isLokiClientUsable() {
+    return instance.has() || instance.hasFactory();
+}
+
+export function useLokiClient() {
+    return instance.use();
+}

package/test/unit/log-store.spec.ts

@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2025.
+ *  Author Peter Placzek (tada5hi)
+ *  For the full copyright and license information,
+ *  view the LICENSE file that was distributed with this source code.
+ */
+
+import { MemoryLogStore } from '../../src';
+
+describe('log-store', () => {
+    it('should permit label management', () => {
+        const store = new MemoryLogStore();
+        store.setLabels({ app: 'app' });
+        store.extendLabels({ foo: 'bar' });
+
+        expect(store.getLabels()).toEqual({
+            app: 'app',
+            foo: 'bar',
+        });
+    });
+});

package/test/unit/logger.spec.ts

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2025.
+ *  Author Peter Placzek (tada5hi)
+ *  For the full copyright and license information,
+ *  view the LICENSE file that was distributed with this source code.
+ */
+
+import { wait } from '@privateaim/kit';
+import { MemoryLogStore, createLogger } from '../../src';
+
+describe('logger', () => {
+    it('should work with store', async () => {
+        const store = new MemoryLogStore();
+        store.setLabels({ app: 'app' });
+
+        const logger = createLogger({
+            store,
+        });
+
+        logger.info('foo', { meta: 'bar' });
+
+        await wait(0);
+
+        expect(store.items).toHaveLength(1);
+
+        const [item] = store.items;
+
+        expect(item.level).toEqual('info');
+        expect(item.message).toEqual('foo');
+        expect(item.labels).toEqual({
+            app: 'app',
+            meta: 'bar',
+        });
+        expect(item.time).toBeDefined();
+    });
+});

package/dist/services/domain-event/type.d.ts

@@ -1,15 +0,0 @@
-import type { DomainEventRecord } from '@privateaim/kit';
-export type DomainEventChannelName = string | ((id?: string | number) => string);
-export type DomainEventDestination = {
-    namespace?: string;
-    channel: DomainEventChannelName;
-};
-export type DomainEventDestinations = DomainEventDestination[];
-export type DomainEventPublishContext<T extends DomainEventRecord = DomainEventRecord> = {
-    data: T;
-    destinations: DomainEventDestinations;
-};
-export interface IDomainEventPublisher {
-    publish(ctx: DomainEventPublishContext): Promise<void>;
-}
-//# sourceMappingURL=type.d.ts.map

package/dist/services/domain-event/type.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"type.d.ts","sourceRoot":"","sources":["../../../src/services/domain-event/type.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEzD,MAAM,MAAM,sBAAsB,GAAG,MAAM,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,KAAK,MAAM,CAAC,CAAC;AACjF,MAAM,MAAM,sBAAsB,GAAG;IACjC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,sBAAsB,CAAA;CAClC,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG,sBAAsB,EAAE,CAAC;AAE/D,MAAM,MAAM,yBAAyB,CACjC,CAAC,SAAS,iBAAiB,GAAG,iBAAiB,IAC/C;IACA,IAAI,EAAE,CAAC,CAAC;IACR,YAAY,EAAE,uBAAuB,CAAA;CACxC,CAAC;AAEF,MAAM,WAAW,qBAAqB;IAClC,OAAO,CAAC,GAAG,EAAE,yBAAyB,GAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3D"}

package/src/services/domain-event/type.ts

@@ -1,27 +0,0 @@
-/*
- * Copyright (c) 2022-2024.
- * Author Peter Placzek (tada5hi)
- * For the full copyright and license information,
- * view the LICENSE file that was distributed with this source code.
- */
-
-import type { DomainEventRecord } from '@privateaim/kit';
-
-export type DomainEventChannelName = string | ((id?: string | number) => string);
-export type DomainEventDestination = {
-    namespace?: string,
-    channel: DomainEventChannelName
-};
-
-export type DomainEventDestinations = DomainEventDestination[];
-
-export type DomainEventPublishContext<
-    T extends DomainEventRecord = DomainEventRecord,
-> = {
-    data: T,
-    destinations: DomainEventDestinations
-};
-
-export interface IDomainEventPublisher {
-    publish(ctx: DomainEventPublishContext) : Promise<void>;
-}