@arcraz/common 1.0.0

package/dist/config/schemas.d.ts

@@ -0,0 +1,193 @@
+import { z } from 'zod';
+/**
+ * Database configuration schema
+ */
+export declare const DatabaseConfigSchema: z.ZodObject<{
+    name: z.ZodString;
+    host: z.ZodString;
+    port: z.ZodDefault<z.ZodNumber>;
+    database: z.ZodString;
+    user: z.ZodString;
+    password: z.ZodString;
+    ssl: z.ZodDefault<z.ZodBoolean>;
+    maxConnections: z.ZodDefault<z.ZodNumber>;
+    idleTimeoutMs: z.ZodDefault<z.ZodNumber>;
+    connectionTimeoutMs: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    host: string;
+    port: number;
+    database: string;
+    user: string;
+    password: string;
+    ssl: boolean;
+    maxConnections: number;
+    idleTimeoutMs: number;
+    connectionTimeoutMs: number;
+}, {
+    name: string;
+    host: string;
+    database: string;
+    user: string;
+    password: string;
+    port?: number | undefined;
+    ssl?: boolean | undefined;
+    maxConnections?: number | undefined;
+    idleTimeoutMs?: number | undefined;
+    connectionTimeoutMs?: number | undefined;
+}>;
+/**
+ * Redis configuration schema - supports single instance or cluster
+ */
+export declare const RedisConfigSchema: z.ZodObject<{
+    host: z.ZodDefault<z.ZodString>;
+    port: z.ZodDefault<z.ZodNumber>;
+    password: z.ZodOptional<z.ZodString>;
+    db: z.ZodDefault<z.ZodNumber>;
+    keyPrefix: z.ZodOptional<z.ZodString>;
+    tls: z.ZodDefault<z.ZodBoolean>;
+    connectTimeout: z.ZodDefault<z.ZodNumber>;
+    commandTimeout: z.ZodDefault<z.ZodNumber>;
+    retryDelayMs: z.ZodDefault<z.ZodNumber>;
+    maxRetries: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    host: string;
+    port: number;
+    db: number;
+    tls: boolean;
+    connectTimeout: number;
+    commandTimeout: number;
+    retryDelayMs: number;
+    maxRetries: number;
+    password?: string | undefined;
+    keyPrefix?: string | undefined;
+}, {
+    host?: string | undefined;
+    port?: number | undefined;
+    password?: string | undefined;
+    db?: number | undefined;
+    keyPrefix?: string | undefined;
+    tls?: boolean | undefined;
+    connectTimeout?: number | undefined;
+    commandTimeout?: number | undefined;
+    retryDelayMs?: number | undefined;
+    maxRetries?: number | undefined;
+}>;
+export declare const RedisClusterConfigSchema: z.ZodObject<{
+    nodes: z.ZodArray<z.ZodObject<{
+        host: z.ZodString;
+        port: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        host: string;
+        port: number;
+    }, {
+        host: string;
+        port: number;
+    }>, "many">;
+    password: z.ZodOptional<z.ZodString>;
+    keyPrefix: z.ZodOptional<z.ZodString>;
+    tls: z.ZodDefault<z.ZodBoolean>;
+    connectTimeout: z.ZodDefault<z.ZodNumber>;
+    commandTimeout: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    tls: boolean;
+    connectTimeout: number;
+    commandTimeout: number;
+    nodes: {
+        host: string;
+        port: number;
+    }[];
+    password?: string | undefined;
+    keyPrefix?: string | undefined;
+}, {
+    nodes: {
+        host: string;
+        port: number;
+    }[];
+    password?: string | undefined;
+    keyPrefix?: string | undefined;
+    tls?: boolean | undefined;
+    connectTimeout?: number | undefined;
+    commandTimeout?: number | undefined;
+}>;
+/**
+ * RabbitMQ configuration schema
+ */
+export declare const RabbitMQConfigSchema: z.ZodObject<{
+    host: z.ZodString;
+    port: z.ZodDefault<z.ZodNumber>;
+    username: z.ZodString;
+    password: z.ZodString;
+    vhost: z.ZodDefault<z.ZodString>;
+    heartbeat: z.ZodDefault<z.ZodNumber>;
+    connectionTimeout: z.ZodDefault<z.ZodNumber>;
+    reconnectDelayMs: z.ZodDefault<z.ZodNumber>;
+    maxReconnectAttempts: z.ZodDefault<z.ZodNumber>;
+    prefetchCount: z.ZodDefault<z.ZodNumber>;
+    protocol: z.ZodDefault<z.ZodEnum<["amqp", "amqps"]>>;
+}, "strip", z.ZodTypeAny, {
+    host: string;
+    port: number;
+    password: string;
+    username: string;
+    vhost: string;
+    heartbeat: number;
+    connectionTimeout: number;
+    reconnectDelayMs: number;
+    maxReconnectAttempts: number;
+    prefetchCount: number;
+    protocol: "amqp" | "amqps";
+}, {
+    host: string;
+    password: string;
+    username: string;
+    port?: number | undefined;
+    vhost?: string | undefined;
+    heartbeat?: number | undefined;
+    connectionTimeout?: number | undefined;
+    reconnectDelayMs?: number | undefined;
+    maxReconnectAttempts?: number | undefined;
+    prefetchCount?: number | undefined;
+    protocol?: "amqp" | "amqps" | undefined;
+}>;
+/**
+ * Logging configuration schema
+ */
+export declare const LoggingConfigSchema: z.ZodObject<{
+    level: z.ZodDefault<z.ZodEnum<["debug", "info", "warn", "error"]>>;
+    format: z.ZodDefault<z.ZodEnum<["json", "logfmt", "pretty"]>>;
+    timestamp: z.ZodDefault<z.ZodBoolean>;
+    colorize: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    level: "debug" | "info" | "warn" | "error";
+    format: "json" | "logfmt" | "pretty";
+    timestamp: boolean;
+    colorize: boolean;
+}, {
+    level?: "debug" | "info" | "warn" | "error" | undefined;
+    format?: "json" | "logfmt" | "pretty" | undefined;
+    timestamp?: boolean | undefined;
+    colorize?: boolean | undefined;
+}>;
+/**
+ * Validates configuration against a schema
+ * @param schema The Zod schema to validate against
+ * @param data The data to validate
+ * @returns Validated and typed configuration
+ * @throws ZodError if validation fails
+ */
+export declare function validateConfig<T extends z.ZodType>(schema: T, data: unknown): z.infer<T>;
+/**
+ * Safely validates configuration, returning result object instead of throwing
+ * @param schema The Zod schema to validate against
+ * @param data The data to validate
+ * @returns Object with success flag and either data or error
+ */
+export declare function safeValidateConfig<T extends z.ZodType>(schema: T, data: unknown): {
+    success: true;
+    data: z.infer<T>;
+} | {
+    success: false;
+    error: z.ZodError;
+};
+//# sourceMappingURL=schemas.d.ts.map

package/dist/config/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/config/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAW/B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAW5B,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAcnC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAY/B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;EAK9B,CAAC;AAEH;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAExF;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,GAAG;IAAE,OAAO,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;CAAE,GAAG;IAAE,OAAO,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,CAAC,CAAC,QAAQ,CAAA;CAAE,CAM7J"}

package/dist/config/schemas.js

@@ -0,0 +1,92 @@
+import { z } from 'zod';
+/**
+ * Database configuration schema
+ */
+export const DatabaseConfigSchema = z.object({
+    name: z.string().min(1),
+    host: z.string().min(1),
+    port: z.number().int().positive().default(5432),
+    database: z.string().min(1),
+    user: z.string().min(1),
+    password: z.string(),
+    ssl: z.boolean().default(false),
+    maxConnections: z.number().int().positive().default(10),
+    idleTimeoutMs: z.number().int().nonnegative().default(30000),
+    connectionTimeoutMs: z.number().int().positive().default(5000)
+});
+/**
+ * Redis configuration schema - supports single instance or cluster
+ */
+export const RedisConfigSchema = z.object({
+    host: z.string().min(1).default('localhost'),
+    port: z.number().int().positive().default(6379),
+    password: z.string().optional(),
+    db: z.number().int().nonnegative().default(0),
+    keyPrefix: z.string().optional(),
+    tls: z.boolean().default(false),
+    connectTimeout: z.number().int().positive().default(10000),
+    commandTimeout: z.number().int().positive().default(5000),
+    retryDelayMs: z.number().int().positive().default(50),
+    maxRetries: z.number().int().nonnegative().default(10)
+});
+export const RedisClusterConfigSchema = z.object({
+    nodes: z
+        .array(z.object({
+        host: z.string().min(1),
+        port: z.number().int().positive()
+    }))
+        .min(1),
+    password: z.string().optional(),
+    keyPrefix: z.string().optional(),
+    tls: z.boolean().default(false),
+    connectTimeout: z.number().int().positive().default(10000),
+    commandTimeout: z.number().int().positive().default(5000)
+});
+/**
+ * RabbitMQ configuration schema
+ */
+export const RabbitMQConfigSchema = z.object({
+    host: z.string().min(1),
+    port: z.number().int().positive().default(5672),
+    username: z.string().min(1),
+    password: z.string(),
+    vhost: z.string().default('/'),
+    heartbeat: z.number().int().nonnegative().default(60),
+    connectionTimeout: z.number().int().positive().default(30000),
+    reconnectDelayMs: z.number().int().positive().default(5000),
+    maxReconnectAttempts: z.number().int().nonnegative().default(10),
+    prefetchCount: z.number().int().positive().default(1),
+    protocol: z.enum(['amqp', 'amqps']).default('amqp')
+});
+/**
+ * Logging configuration schema
+ */
+export const LoggingConfigSchema = z.object({
+    level: z.enum(['debug', 'info', 'warn', 'error']).default('info'),
+    format: z.enum(['json', 'logfmt', 'pretty']).default('json'),
+    timestamp: z.boolean().default(true),
+    colorize: z.boolean().default(false)
+});
+/**
+ * Validates configuration against a schema
+ * @param schema The Zod schema to validate against
+ * @param data The data to validate
+ * @returns Validated and typed configuration
+ * @throws ZodError if validation fails
+ */
+export function validateConfig(schema, data) {
+    return schema.parse(data);
+}
+/**
+ * Safely validates configuration, returning result object instead of throwing
+ * @param schema The Zod schema to validate against
+ * @param data The data to validate
+ * @returns Object with success flag and either data or error
+ */
+export function safeValidateConfig(schema, data) {
+    const result = schema.safeParse(data);
+    if (result.success) {
+        return { success: true, data: result.data };
+    }
+    return { success: false, error: result.error };
+}

package/dist/config/types.d.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { DatabaseConfigSchema, RedisConfigSchema, RedisClusterConfigSchema, RabbitMQConfigSchema, LoggingConfigSchema } from './schemas.js';
+/**
+ * Database configuration type
+ */
+export type DatabaseConfig = z.infer<typeof DatabaseConfigSchema>;
+/**
+ * Redis single instance configuration type
+ */
+export type RedisConfig = z.infer<typeof RedisConfigSchema>;
+/**
+ * Redis cluster configuration type
+ */
+export type RedisClusterConfig = z.infer<typeof RedisClusterConfigSchema>;
+/**
+ * RabbitMQ configuration type
+ */
+export type RabbitMQConfig = z.infer<typeof RabbitMQConfigSchema>;
+/**
+ * Logging configuration type
+ */
+export type LoggingConfig = z.infer<typeof LoggingConfigSchema>;
+//# sourceMappingURL=types.d.ts.map

package/dist/config/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/config/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,wBAAwB,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAE5I;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

package/dist/config/types.js

@@ -0,0 +1,2 @@
+import { z } from 'zod';
+import { DatabaseConfigSchema, RedisConfigSchema, RedisClusterConfigSchema, RabbitMQConfigSchema, LoggingConfigSchema } from './schemas.js';

package/dist/constants/cache-durations.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Standard cache duration constants in seconds
+ */
+export declare const CACHE_DURATION: {
+    /** 1 minute */
+    readonly ONE_MINUTE: 60;
+    /** 5 minutes */
+    readonly FIVE_MINUTES: 300;
+    /** 15 minutes */
+    readonly FIFTEEN_MINUTES: 900;
+    /** 30 minutes */
+    readonly THIRTY_MINUTES: 1800;
+    /** 1 hour */
+    readonly ONE_HOUR: 3600;
+    /** 2 hours */
+    readonly TWO_HOURS: 7200;
+    /** 6 hours */
+    readonly SIX_HOURS: 21600;
+    /** 12 hours */
+    readonly TWELVE_HOURS: 43200;
+    /** 1 day */
+    readonly ONE_DAY: 86400;
+    /** 1 week */
+    readonly ONE_WEEK: 604800;
+    /** 30 days */
+    readonly ONE_MONTH: 2592000;
+};
+export type CacheDuration = (typeof CACHE_DURATION)[keyof typeof CACHE_DURATION];
+//# sourceMappingURL=cache-durations.d.ts.map

package/dist/constants/cache-durations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-durations.d.ts","sourceRoot":"","sources":["../../src/constants/cache-durations.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,cAAc;IACzB,eAAe;;IAEf,gBAAgB;;IAEhB,iBAAiB;;IAEjB,iBAAiB;;IAEjB,aAAa;;IAEb,cAAc;;IAEd,cAAc;;IAEd,eAAe;;IAEf,YAAY;;IAEZ,aAAa;;IAEb,cAAc;;CAEN,CAAC;AAEX,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,OAAO,cAAc,CAAC,CAAC"}

package/dist/constants/cache-durations.js

@@ -0,0 +1,27 @@
+/**
+ * Standard cache duration constants in seconds
+ */
+export const CACHE_DURATION = {
+    /** 1 minute */
+    ONE_MINUTE: 60,
+    /** 5 minutes */
+    FIVE_MINUTES: 300,
+    /** 15 minutes */
+    FIFTEEN_MINUTES: 900,
+    /** 30 minutes */
+    THIRTY_MINUTES: 1800,
+    /** 1 hour */
+    ONE_HOUR: 3600,
+    /** 2 hours */
+    TWO_HOURS: 7200,
+    /** 6 hours */
+    SIX_HOURS: 21600,
+    /** 12 hours */
+    TWELVE_HOURS: 43200,
+    /** 1 day */
+    ONE_DAY: 86400,
+    /** 1 week */
+    ONE_WEEK: 604800,
+    /** 30 days */
+    ONE_MONTH: 2592000
+};

package/dist/constants/defaults.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Default pool sizes for database connections
+ */
+export declare const DATABASE_DEFAULTS: {
+    readonly MAX_CONNECTIONS: 10;
+    readonly IDLE_TIMEOUT_MS: 30000;
+    readonly CONNECTION_TIMEOUT_MS: 5000;
+    readonly STATEMENT_TIMEOUT_MS: 30000;
+};
+/**
+ * Default Redis configuration values
+ */
+export declare const REDIS_DEFAULTS: {
+    readonly PORT: 6379;
+    readonly DB: 0;
+    readonly CONNECT_TIMEOUT_MS: 10000;
+    readonly COMMAND_TIMEOUT_MS: 5000;
+    readonly RETRY_DELAY_MS: 50;
+    readonly MAX_RETRIES: 10;
+};
+/**
+ * Default RabbitMQ configuration values
+ */
+export declare const RABBITMQ_DEFAULTS: {
+    readonly PORT: 5672;
+    readonly HEARTBEAT: 60;
+    readonly CONNECTION_TIMEOUT_MS: 30000;
+    readonly RECONNECT_DELAY_MS: 5000;
+    readonly MAX_RECONNECT_ATTEMPTS: 10;
+    readonly PREFETCH_COUNT: 1;
+    readonly DEFAULT_DELAY_EXCHANGE: "delayed-exchange";
+};
+/**
+ * Default retry configuration
+ */
+export declare const RETRY_DEFAULTS: {
+    readonly MAX_ATTEMPTS: 3;
+    readonly INITIAL_DELAY_MS: 1000;
+    readonly MAX_DELAY_MS: 30000;
+    readonly BACKOFF_MULTIPLIER: 2;
+};
+/**
+ * Default pagination values
+ */
+export declare const PAGINATION_DEFAULTS: {
+    readonly PAGE_SIZE: 50;
+    readonly MAX_PAGE_SIZE: 1000;
+    readonly DEFAULT_PAGE: 1;
+};
+//# sourceMappingURL=defaults.d.ts.map

package/dist/constants/defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaults.d.ts","sourceRoot":"","sources":["../../src/constants/defaults.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;;CAKpB,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;;;CAOjB,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;CAQpB,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;CAKjB,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;CAItB,CAAC"}

package/dist/constants/defaults.js

@@ -0,0 +1,49 @@
+/**
+ * Default pool sizes for database connections
+ */
+export const DATABASE_DEFAULTS = {
+    MAX_CONNECTIONS: 10,
+    IDLE_TIMEOUT_MS: 30000,
+    CONNECTION_TIMEOUT_MS: 5000,
+    STATEMENT_TIMEOUT_MS: 30000
+};
+/**
+ * Default Redis configuration values
+ */
+export const REDIS_DEFAULTS = {
+    PORT: 6379,
+    DB: 0,
+    CONNECT_TIMEOUT_MS: 10000,
+    COMMAND_TIMEOUT_MS: 5000,
+    RETRY_DELAY_MS: 50,
+    MAX_RETRIES: 10
+};
+/**
+ * Default RabbitMQ configuration values
+ */
+export const RABBITMQ_DEFAULTS = {
+    PORT: 5672,
+    HEARTBEAT: 60,
+    CONNECTION_TIMEOUT_MS: 30000,
+    RECONNECT_DELAY_MS: 5000,
+    MAX_RECONNECT_ATTEMPTS: 10,
+    PREFETCH_COUNT: 1,
+    DEFAULT_DELAY_EXCHANGE: 'delayed-exchange'
+};
+/**
+ * Default retry configuration
+ */
+export const RETRY_DEFAULTS = {
+    MAX_ATTEMPTS: 3,
+    INITIAL_DELAY_MS: 1000,
+    MAX_DELAY_MS: 30000,
+    BACKOFF_MULTIPLIER: 2
+};
+/**
+ * Default pagination values
+ */
+export const PAGINATION_DEFAULTS = {
+    PAGE_SIZE: 50,
+    MAX_PAGE_SIZE: 1000,
+    DEFAULT_PAGE: 1
+};

package/dist/constants/index.d.ts

@@ -0,0 +1,4 @@
+export { CACHE_DURATION } from './cache-durations.js';
+export type { CacheDuration } from './cache-durations.js';
+export { DATABASE_DEFAULTS, REDIS_DEFAULTS, RABBITMQ_DEFAULTS, RETRY_DEFAULTS, PAGINATION_DEFAULTS } from './defaults.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/constants/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/constants/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,YAAY,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAE1D,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,iBAAiB,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC"}

package/dist/constants/index.js

@@ -0,0 +1,2 @@
+export { CACHE_DURATION } from './cache-durations.js';
+export { DATABASE_DEFAULTS, REDIS_DEFAULTS, RABBITMQ_DEFAULTS, RETRY_DEFAULTS, PAGINATION_DEFAULTS } from './defaults.js';

package/dist/database/base-repository.d.ts

@@ -0,0 +1,45 @@
+import type { DatabasePool } from './types.js';
+/**
+ * Abstract base repository class for database operations
+ * Extend this class and inject DatabasePool instances via constructor
+ */
+export declare abstract class BaseRepository {
+    protected readonly db: DatabasePool;
+    protected readonly readOnlyDb: DatabasePool;
+    constructor(db: DatabasePool, readOnlyDb?: DatabasePool);
+    /**
+     * Execute a query on the main database
+     * @param text SQL query
+     * @param values Query parameters
+     * @returns Array of camelCased results
+     */
+    protected query<T>(text: string, values?: unknown[]): Promise<T[]>;
+    /**
+     * Execute a query on the read-only database
+     * @param text SQL query
+     * @param values Query parameters
+     * @returns Array of camelCased results
+     */
+    protected queryReadOnly<T>(text: string, values?: unknown[]): Promise<T[]>;
+    /**
+     * Execute a query and return a single result
+     * @param text SQL query
+     * @param values Query parameters
+     * @returns Single camelCased result or null
+     */
+    protected queryOne<T>(text: string, values?: unknown[]): Promise<T | null>;
+    /**
+     * Execute a query on read-only db and return a single result
+     * @param text SQL query
+     * @param values Query parameters
+     * @returns Single camelCased result or null
+     */
+    protected queryOneReadOnly<T>(text: string, values?: unknown[]): Promise<T | null>;
+    /**
+     * Execute a transaction on the main database
+     * @param fn Transaction function receiving a client
+     * @returns Transaction result
+     */
+    protected transaction<T>(fn: (client: import('pg').PoolClient) => Promise<T>): Promise<T>;
+}
+//# sourceMappingURL=base-repository.d.ts.map

package/dist/database/base-repository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-repository.d.ts","sourceRoot":"","sources":["../../src/database/base-repository.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAG/C;;;GAGG;AACH,8BAAsB,cAAc;IAClC,SAAS,CAAC,QAAQ,CAAC,EAAE,EAAE,YAAY,CAAC;IACpC,SAAS,CAAC,QAAQ,CAAC,UAAU,EAAE,YAAY,CAAC;gBAEhC,EAAE,EAAE,YAAY,EAAE,UAAU,CAAC,EAAE,YAAY;IAKvD;;;;;OAKG;cACa,KAAK,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;IAIxE;;;;;OAKG;cACa,aAAa,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;IAIhF;;;;;OAKG;cACa,QAAQ,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IAIhF;;;;;OAKG;cACa,gBAAgB,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IAIxF;;;;OAIG;cACa,WAAW,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,MAAM,EAAE,OAAO,IAAI,EAAE,UAAU,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;CAGhG"}

package/dist/database/base-repository.js

@@ -0,0 +1,57 @@
+import { queryWithCamelCase, queryOneWithCamelCase } from './pool-factory.js';
+/**
+ * Abstract base repository class for database operations
+ * Extend this class and inject DatabasePool instances via constructor
+ */
+export class BaseRepository {
+    db;
+    readOnlyDb;
+    constructor(db, readOnlyDb) {
+        this.db = db;
+        this.readOnlyDb = readOnlyDb ?? db;
+    }
+    /**
+     * Execute a query on the main database
+     * @param text SQL query
+     * @param values Query parameters
+     * @returns Array of camelCased results
+     */
+    async query(text, values) {
+        return queryWithCamelCase(this.db, text, values);
+    }
+    /**
+     * Execute a query on the read-only database
+     * @param text SQL query
+     * @param values Query parameters
+     * @returns Array of camelCased results
+     */
+    async queryReadOnly(text, values) {
+        return queryWithCamelCase(this.readOnlyDb, text, values);
+    }
+    /**
+     * Execute a query and return a single result
+     * @param text SQL query
+     * @param values Query parameters
+     * @returns Single camelCased result or null
+     */
+    async queryOne(text, values) {
+        return queryOneWithCamelCase(this.db, text, values);
+    }
+    /**
+     * Execute a query on read-only db and return a single result
+     * @param text SQL query
+     * @param values Query parameters
+     * @returns Single camelCased result or null
+     */
+    async queryOneReadOnly(text, values) {
+        return queryOneWithCamelCase(this.readOnlyDb, text, values);
+    }
+    /**
+     * Execute a transaction on the main database
+     * @param fn Transaction function receiving a client
+     * @returns Transaction result
+     */
+    async transaction(fn) {
+        return this.db.transaction(fn);
+    }
+}

package/dist/database/helpers/converter-helper.d.ts

@@ -0,0 +1,9 @@
+import type { KeyValuePair } from '../../types/custom-types.js';
+/**
+ * Converts PostgreSQL array fields in an object to TypeScript arrays
+ * @param keysTypes Array of key-value pairs specifying which fields to convert
+ * @param originalObject Object containing fields to convert
+ * @returns Object with converted array fields
+ */
+export declare function ConverterHelper<T>(keysTypes: KeyValuePair[], originalObject: T): T;
+//# sourceMappingURL=converter-helper.d.ts.map

package/dist/database/helpers/converter-helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"converter-helper.d.ts","sourceRoot":"","sources":["../../../src/database/helpers/converter-helper.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAGhE;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,SAAS,EAAE,YAAY,EAAE,EAAE,cAAc,EAAE,CAAC,GAAG,CAAC,CAelF"}

package/dist/database/helpers/converter-helper.js

@@ -0,0 +1,20 @@
+import { parsePostgresArray } from '../query-helpers.js';
+/**
+ * Converts PostgreSQL array fields in an object to TypeScript arrays
+ * @param keysTypes Array of key-value pairs specifying which fields to convert
+ * @param originalObject Object containing fields to convert
+ * @returns Object with converted array fields
+ */
+export function ConverterHelper(keysTypes, originalObject) {
+    if (!originalObject) {
+        return originalObject;
+    }
+    const result = { ...originalObject };
+    for (const pair of keysTypes) {
+        const key = String(pair.key);
+        if (key in result) {
+            result[key] = parsePostgresArray(result[key]);
+        }
+    }
+    return result;
+}

package/dist/database/helpers/index.d.ts

@@ -0,0 +1,3 @@
+export { ConverterHelper } from './converter-helper.js';
+export { PagedResponseHelper } from './paged-response-helper.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/database/helpers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/database/helpers/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC"}

package/dist/database/helpers/index.js

@@ -0,0 +1,2 @@
+export { ConverterHelper } from './converter-helper.js';
+export { PagedResponseHelper } from './paged-response-helper.js';