@estopia/shared 1.0.0 → 1.0.2

package/dist/types/user.d.ts

@@ -0,0 +1,29 @@
+export interface UserDto {
+    id: string;
+    username: string;
+    password: string | null;
+    icon: string;
+    isAdmin: boolean;
+}
+export interface PasskeyDto {
+    id: string;
+    name: string;
+    transports: number;
+}
+export interface AuthAppDto {
+    id: string;
+    name: string;
+}
+export interface NotificationSettingsDto {
+    id: string;
+    userId: number;
+    directMessage: boolean;
+    groupDMMessage: boolean;
+    groupDMMention: boolean;
+    addedToDM: boolean;
+    serverEveryoneMention: boolean;
+    serverMention: boolean;
+    serverReply: boolean;
+    directCall: boolean;
+}
+//# sourceMappingURL=user.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"user.d.ts","sourceRoot":"","sources":["../../src/types/user.ts"],"names":[],"mappings":"AACA,MAAM,WAAW,OAAO;IACtB,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;CAEpB;AAED,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;CAEd;AAED,MAAM,WAAW,uBAAuB;IACtC,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,OAAO,CAAC;IACvB,cAAc,EAAE,OAAO,CAAC;IACxB,cAAc,EAAE,OAAO,CAAC;IACxB,SAAS,EAAE,OAAO,CAAC;IACnB,qBAAqB,EAAE,OAAO,CAAC;IAC/B,aAAa,EAAE,OAAO,CAAC;IACvB,WAAW,EAAE,OAAO,CAAC;IACrB,UAAU,EAAE,OAAO,CAAC;CACrB"}

package/dist/types/user.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=user.js.map

package/dist/types/user.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"user.js","sourceRoot":"","sources":["../../src/types/user.ts"],"names":[],"mappings":""}

package/package.json

@@ -1,13 +1,15 @@
 {
   "name": "@estopia/shared",
-  "version": "1.0.0",
-  "main": "src/index.ts",
-  "types": "src/index.d.ts",
+  "version": "1.0.2",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "description": "",
   "author": "",
   "license": "ISC",
   "scripts": {
-    "build": "tsc -p tsconfig.json",
+  "build": "tsc -p tsconfig.json",
+  "build:dist": "tsc -p tsconfig.build.json",
+  "prepare": "npm run build:dist",
     "test": "vitest",
     "test:watch": "vitest --watch",
     "db:types": "kysely-codegen --out-file ./src/database/dataTypes.ts"
@@ -23,6 +25,10 @@
     "pino": "^10.0.0",
     "vitest": "^3.2.4"
   },
+  "files": [
+    "dist",
+    "src/database/dataTypes.ts"
+  ],
   "devDependencies": {
     "@types/amqplib": "^0.10.7",
     "@types/express": "^5.0.3",

package/.github/workflows/tests.yml

@@ -1,29 +0,0 @@
-name: Tests
-
-on:
-  push:
-    branches: [ main ]
-  pull_request:
-    branches: [ main ]
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-
-    steps:
-    - uses: actions/checkout@v3
-
-    - name: Use Node.js
-      uses: actions/setup-node@v3
-      with:
-        node-version: '18'
-
-    - name: Install package dependencies
-      run: |
-        npm install
-      shell: bash
-
-    - name: Run tests
-      run: |
-        npm test
-    

package/scripts/migrations/1670000000000-initial.js

@@ -1,107 +0,0 @@
-/* eslint-disable no-unused-vars */
-'use strict';
-
-exports.up = (pgm) => {
-  // 1. Create Custom Enum Types
-  pgm.createType('verification_type', ['email', 'phone', 'password_reset']);
-  pgm.createType('factor_auth_type', ['whatsapp', 'email']);
-  pgm.createType('app_type', ['medIOS', 'medAndroid', 'web']);
-
-  // 2. Create Core User Table
-  pgm.createTable('users', {
-    id: 'id',
-    username: { type: 'varchar(50)', notNull: true, unique: true },
-    password_hash: { type: 'text', notNull: true },
-    disabled: { type: 'boolean', default: false },
-    is_admin: { type: 'boolean', default: false },
-    icon_url: { type: 'text' },
-    created_at: { type: 'timestamptz', notNull: true, default: pgm.func('now()') },
-  });
-
-  // 3. Create Related Authentication & Settings Tables
-  pgm.createTable('notification_settings', {
-    id: 'id',
-    user_id: { type: 'integer', notNull: true, references: 'users(id)', onDelete: 'CASCADE', unique: true },
-    direct_message: { type: 'boolean', default: true },
-    group_dm_message: { type: 'boolean', default: true },
-    group_dm_mention: { type: 'boolean', default: true },
-    added_to_dm: { type: 'boolean', default: true },
-    server_everyone_mention: { type: 'boolean', default: true },
-    server_mention: { type: 'boolean', default: true },
-    server_reply: { type: 'boolean', default: true },
-    direct_call: { type: 'boolean', default: true },
-  });
-
-  pgm.createTable('user_verifications', {
-    id: 'id',
-    user_id: { type: 'integer', notNull: true, references: 'users(id)', onDelete: 'CASCADE' },
-    ownership_code: { type: 'text', notNull: true },
-    is_verified: { type: 'boolean', default: false },
-    type: { type: 'verification_type', notNull: true },
-    data: { type: 'text' },
-    expiry_at: { type: 'timestamptz', notNull: true },
-    created_at: { type: 'timestamptz', notNull: true, default: pgm.func('now()') },
-  });
-
-  pgm.createTable('passkeys', {
-    id: 'id',
-    user_id: { type: 'integer', notNull: true, references: 'users(id)', onDelete: 'CASCADE' },
-    key_id: { type: 'bytea', notNull: true, unique: true },
-    public_key: { type: 'bytea', notNull: true },
-    counter: { type: 'bigint', notNull: true },
-    transports: { type: 'varchar(50)[]' },
-    name: { type: 'text' },
-  });
-
-  pgm.createTable('auth_apps', {
-    id: 'id',
-    user_id: { type: 'integer', notNull: true, references: 'users(id)', onDelete: 'CASCADE' },
-    secret: { type: 'text', notNull: true },
-    name: { type: 'varchar(100)', notNull: true },
-  });
-  
-  pgm.createTable('factor_authentication', {
-    id: 'id',
-    user_id: { type: 'integer', notNull: true, references: 'users(id)', onDelete: 'CASCADE' },
-    type: { type: 'factor_auth_type', notNull: true },
-    data: { type: 'text', notNull: true },
-    code: { type: 'text', notNull: true },
-    is_verified: { type: 'boolean', default: false },
-    expiry_at: { type: 'timestamptz', notNull: true },
-  });
-
-  pgm.createTable('tokens', {
-    id: 'id',
-    user_id: { type: 'integer', notNull: true, references: 'users(id)', onDelete: 'CASCADE' },
-    refresh_token: { type: 'uuid', notNull: true, unique: true },
-    fcm_token: { type: 'text' },
-    app: { type: 'app_type', notNull: false },
-    expiry_at: { type: 'timestamptz', notNull: true },
-    created_at: { type: 'timestamptz', notNull: true, default: pgm.func('now()') },
-  });
-
-  pgm.createTable('secure_tokens', {
-    id: 'id',
-    user_id: { type: 'integer', notNull: true, references: 'users(id)', onDelete: 'CASCADE' },
-    token_uuid: { type: 'uuid', notNull: true, unique: true },
-    expiry_at: { type: 'timestamptz', notNull: true },
-    created_at: { type: 'timestamptz', notNull: true, default: pgm.func('now()') },
-  });
-};
-
-exports.down = (pgm) => {
-  // Drop tables in reverse order of creation due to dependencies
-  pgm.dropTable('secure_tokens');
-  pgm.dropTable('tokens');
-  pgm.dropTable('factor_authentication');
-  pgm.dropTable('auth_apps');
-  pgm.dropTable('passkeys');
-  pgm.dropTable('user_verifications');
-  pgm.dropTable('notification_settings');
-  pgm.dropTable('users');
-
-  // Drop types
-  pgm.dropType('app_type');
-  pgm.dropType('factor_auth_type');
-  pgm.dropType('verification_type');
-};

package/scripts/package.json

@@ -1,20 +0,0 @@
-{
-  "name": "@estopia/scripts",
-  "version": "1.0.0",
-  "main": "index.ts",
-  "types": "src/index.d.ts",
-  "description": "",
-  "author": "",
-  "license": "ISC",
-  "scripts": {
-    "migrate:up": "dotenv -e .env -- node-pg-migrate up -u \"$DATABASE_URL\"",
-    "migrate:down": "dotenv -e .env -- node-pg-migrate down -u \"$DATABASE_URL\""
-  },
-  "dependencies": {
-    "dotenv": "^17.2.3",
-    "node-pg-migrate": "^8.0.3"
-  },
-  "devDependencies": {
-    "dotenv-cli": "^10.0.0"
-  }
-}

package/src/broker/eventTypes.ts

@@ -1,23 +0,0 @@
-export interface UserRegisteredEvent {
-  userId: string;
-  email: string;
-  verificationCode: string;
-}
-
-export interface PasswordResetEvent {
-  userId: string;
-  email: string;
-  resetToken: string;
-}
-
-export type EventPayloads = UserRegisteredEvent | PasswordResetEvent;
-
-export interface EventMap {
-  USER_REGISTERED: UserRegisteredEvent;
-  PASSWORD_RESET: PasswordResetEvent;
-}
-
-export const EVENTS = {
-  USER_REGISTERED: 'user.registered',
-  PASSWORD_RESET: 'password.reset',
-} as const;

package/src/broker/publisher.ts

@@ -1,82 +0,0 @@
-import * as amqplib from 'amqplib';
-import { EventPayloads, EventMap, EVENTS } from './eventTypes';
-
-export class EventPublisher {
-  private connection?: any;
-  private channel?: any;
-  private exchange = 'estopia.events';
-
-  constructor(private url: string) {}
-
-  async connect() {
-    if (this.connection && this.channel) return; // already connected
-    this.connection = await amqplib.connect(this.url);
-    this.channel = await this.connection.createChannel();
-    await this.channel.assertExchange(this.exchange, 'topic', { durable: true });
-  }
-
-  /**
-   * Publish an event. The payload type is keyed by the same keys used in your EventPayloads map.
-   * Ensures the routing key exists in EVENTS and that the publisher is connected.
-   */
-  async publish<K extends keyof EventMap>(eventName: K, payload: EventMap[K]) {
-    // Auto-connect if needed
-    if (!this.channel) {
-      await this.connect();
-    }
-
-    const routingKey = EVENTS[eventName as keyof typeof EVENTS];
-    if (!routingKey || typeof routingKey !== 'string') {
-      throw new Error(`No routing key configured for event ${String(eventName)}`);
-    }
-
-    let body: Buffer;
-    try {
-      body = Buffer.from(JSON.stringify(payload));
-    } catch (err) {
-      throw new Error('Failed to serialize payload for publish');
-    }
-
-    // Basic retry with exponential backoff
-    const maxRetries = 3;
-    const baseBackoffMs = 200;
-
-    for (let attempt = 0; attempt <= maxRetries; attempt++) {
-      try {
-        // channel.publish is synchronous; wrap in try/catch in case of closed channel
-        this.channel.publish(this.exchange, routingKey, body, { persistent: true });
-        return;
-      } catch (err) {
-        // if last attempt, rethrow
-        if (attempt === maxRetries) throw err;
-        // try reconnect + backoff
-        try {
-          // reset connection and attempt reconnect
-          await this.close();
-        } catch (_) {}
-        try {
-          await this.connect();
-        } catch (_) {
-          // failed to reconnect, will backoff and retry loop
-        }
-        const backoff = baseBackoffMs * Math.pow(2, attempt);
-        await new Promise((res) => setTimeout(res, backoff));
-      }
-    }
-  }
-
-  async close() {
-    try {
-      if (this.channel) await this.channel.close();
-    } catch (e) {
-      // ignore
-    }
-    try {
-      if (this.connection) await this.connection.close();
-    } catch (e) {
-      // ignore
-    }
-    this.channel = undefined;
-    this.connection = undefined;
-  }
-}

package/src/broker/subscriber.ts

@@ -1,51 +0,0 @@
-const amqplib = require('amqplib');
-import { EVENTS, EventMap } from './eventTypes';
-
-type EventHandler<T> = (payload: T) => Promise<void> | void;
-
-export class EventSubscriber {
-  private connection?: any;
-  private channel?: any;
-  private exchange = 'estopia.events';
-
-  constructor(private url: string) {}
-
-  async connect() {
-    if (this.connection && this.channel) return;
-    this.connection = await amqplib.connect(this.url);
-    this.channel = await this.connection.createChannel();
-    await this.channel.assertExchange(this.exchange, 'topic', { durable: true });
-  }
-
-  async subscribe<K extends keyof EventMap>(eventName: K, handler: EventHandler<EventMap[K]>) {
-    if (!this.channel) throw new Error('Subscriber not connected');
-
-    const q = await this.channel.assertQueue('', { exclusive: true });
-  const routing = EVENTS[eventName as keyof typeof EVENTS];
-  await this.channel.bindQueue(q.queue, this.exchange, routing);
-
-    await this.channel.consume(q.queue, (msg: any | null) => {
-      if (msg) {
-        let payload: EventMap[K];
-        try {
-          payload = JSON.parse(msg.content.toString());
-        } catch (err) {
-          // malformed message -> nack and requeue false
-          this.channel?.nack(msg, false, false);
-          return;
-        }
-
-        Promise.resolve(handler(payload))
-          .then(() => this.channel?.ack(msg))
-          .catch(() => this.channel?.nack(msg, false, true));
-      }
-    });
-  }
-
-  async close() {
-    try { if (this.channel) await this.channel.close(); } catch (e) { }
-    try { if (this.connection) await this.connection.close(); } catch (e) { }
-    this.channel = undefined;
-    this.connection = undefined;
-  }
-}

package/src/database/cockroach.ts

@@ -1,27 +0,0 @@
-import { Pool } from 'pg';
-import { CockroachConfig } from './types';
-import { Kysely, PostgresDialect } from 'kysely';
-import { DB } from './dataTypes';
-
-/**
- * Creates and tests a new connection pool for a CockroachDB cluster.
- * * @param config - The connection configuration for CockroachDB.
- * @returns A promise that resolves to a connected Pool instance.
- * @throws Will throw an error if the connection fails.
- */
-export async function createCockroachDBConnection(config: CockroachConfig): Promise<Kysely<DB>> {
-  try {
-
-    const db = new Kysely<DB>({
-      dialect: new PostgresDialect({
-        pool: new Pool(config)
-      })
-    });
-
-    console.log('Successfully connected to CockroachDB.');
-    return db;
-  } catch (error) {
-    console.error('Failed to connect to CockroachDB:', error);
-    throw error;
-  }
-}

package/src/helpers/middlware/auth.ts

@@ -1,55 +0,0 @@
-import { EstopiaRequest } from '../../types/request';
-import { validateJWTToken } from '../validateJWTToken';
-
-/**
- * Middleware to require authentication.
- * - Supports Authorization: Bearer <token> header (case-insensitive)
- * - Falls back to cookies.auth_token
- * - On success: sets req.auth = { ...payload, token } and calls next()
- * - On failure: responds with 401 and an appropriate error message
- */
-export function requireAuth(req: EstopiaRequest, res: any, next: any) {
-  // Get Authorization header (many frameworks provide case-insensitive header lookup)
-  const authHeader = typeof req.header === 'function' ? req.header('Authorization') : undefined;
-
-  // Extract token from "Bearer <token>" or use header value directly
-  let token: string | undefined;
-  if (typeof authHeader === 'string' && authHeader.trim() !== '') {
-    const bearerMatch = authHeader.match(/^\s*Bearer\s+(.+)\s*$/i);
-    token = bearerMatch ? bearerMatch[1] : authHeader.trim();
-  }
-
-  // Fallback to cookie
-  if (!token && req && req.cookies && typeof req.cookies.auth_token === 'string') {
-    token = req.cookies.auth_token;
-  }
-
-  if (!token) {
-    return res.status(401).json({ error: 'Missing authorization token' });
-  }
-
-  try {
-    const payload = validateJWTToken(token);
-    if (!payload) {
-      return res.status(401).json({ error: 'Invalid token' });
-    }
-
-    // Attach auth info to request
-    req.auth = { ...payload, token };
-    return next();
-  } catch (err: any) {
-    // Log warning if logger available, otherwise fallback to console
-    try {
-      if (req && req.logger && typeof req.logger.warn === 'function') {
-        req.logger.warn('Auth verification failed', err);
-      } else {
-        // Keep message concise for logs
-        // eslint-disable-next-line no-console
-        console.warn('Auth verification failed', err);
-      }
-    } catch {
-      // swallow logging errors
-    }
-    return res.status(401).json({ error: 'Invalid authorization' });
-  }
-}

package/src/helpers/middlware/secure.ts

@@ -1,48 +0,0 @@
-import { Response } from 'express';
-import { EstopiaRequest } from '../../types/request';
-import type { Kysely } from 'kysely';
-import type { DB } from '../../database/dataTypes';
-
-/**
- * Middleware to require authentication.
- * - Supports Authorization: Bearer <token> header (case-insensitive)
- * - Falls back to cookies.auth_token
- * - On success: sets req.auth = { ...payload, token } and calls next()
- * - On failure: responds with 401 and an appropriate error message
- */
-export async function requireSecure(req: EstopiaRequest, res: Response, next: any) {
-  // This middleware only validates the Secure-Token cookie against the DB.
-  // It does NOT require a valid JWT — per request: "it doesn't matter if the JWT token exists".
-
-  // Read secure token from cookie
-  const secureToken = req && req.cookies['Secure-Token'];
-  if (!secureToken) {
-    return res.status(403).json({ error: 'Missing secure token' });
-  }
-
-  // Expect a Kysely DB instance to be available on app.locals.db
-  const cockroachPool = req.cockroachPool;
-
-  try {
-    const db = cockroachPool as Kysely<DB>;
-    // Query secure_tokens table by token_uuid
-    const row = await db.selectFrom('secure_tokens').selectAll().where('token_uuid', '=', secureToken).executeTakeFirst();
-
-    if (!row) {
-      return res.status(403).json({ error: 'Secure token not found' });
-    }
-
-    // expiry_at may be a Date or string depending on driver; normalize
-    const expiry = row.expiry_at ? new Date(row.expiry_at as any) : null;
-    if (!expiry || expiry.getTime() <= Date.now()) {
-      return res.status(403).json({ error: 'Secure token expired' });
-    }
-
-    // Attach minimal auth context to request (no JWT required)
-    req.auth = { secureToken, userId: row.user_id.toString() };
-    return next();
-  } catch (err: any) {
-    console.error('Failed to validate secure token', err?.message || err);
-    return res.status(500).json({ error: 'Failed to validate secure token' });
-  }
-}

package/src/helpers/validateJWTToken.ts

@@ -1,38 +0,0 @@
-import jwt from 'jsonwebtoken';
-
-export interface DecodedJWT {
-  userId: string;
-  jti?: string;
-  iat?: number;
-  exp?: number;
-}
-
-// Keep verification options minimal to allow tokens signed without an explicit issuer in tests.
-const jwtVerifyOptions = {};
-
-/**
- * Verify a JWT and return the decoded payload. Throws on invalid/expired token.
- */
-export function validateJWTToken(token: string): DecodedJWT {
-  const secret = process.env.JWT_SECRET;
-  if (!secret) throw new Error('JWT secret not configured');
-
-  const payload = jwt.verify(token, secret, jwtVerifyOptions) as any;
-  const userId = payload?.sub ?? payload?.userId ?? payload?.id ?? null;
-  if (!userId) throw new Error('token missing subject');
-
-  return { userId, jti: payload.jti ?? payload.jti ?? undefined, iat: payload.iat, exp: payload.exp } as DecodedJWT;
-}
-
-/**
- * Try to verify a token and return the decoded payload, or null if invalid.
- */
-export function tryValidateJWTToken(token: string): DecodedJWT | null {
-  try {
-    return validateJWTToken(token);
-  } catch (e) {
-    return null;
-  }
-}
-
-export default validateJWTToken;

package/src/logging/logger.ts

@@ -1,103 +0,0 @@
-import pino from 'pino';
-import axios from 'axios';
-import { Logger } from '../types/request';
-
-interface LoggerOptions {
-  serviceName: string;
-  logServiceUrl?: string;
-  environment?: "development" | "production";
-  sendLogs?: boolean; // default true
-}
-
-interface LogMeta {
-  [key: string]: any;
-}
-
-export function createLogger(options: LoggerOptions): Logger {
-  const {
-    serviceName,
-    logServiceUrl = process.env.LOG_SERVICE_URL || "http://localhost:4000/logs",
-    environment = process.env.NODE_ENV as "development" | "production" || "development",
-    sendLogs = true,
-  } = options;
-
-  let requestId: string | null = null;
-  let requestURL: string | null = null;
-  let requestMethod: string | null = null;
-  let requestUserId: string | null = null;
-  let requesterType: 'user' | 'internal' | null = null;
-
-  const logger =
-    environment === "development"
-      ? pino({ name: serviceName, level: 'debug' } as any)
-      : pino({
-          name: serviceName,
-          level: 'info',
-        });
-
-  const sendLog = async (level: string, message: string, meta: LogMeta = {}) => {
-    if (!sendLogs) return;
-    try {
-      if (requestId) {
-        meta.requestId = requestId;
-      }
-      if (requestURL) {
-        meta.requestURL = requestURL;
-      }
-      if (requestMethod) {
-        meta.requestMethod = requestMethod;
-      }
-      if (requestUserId) {
-        meta.requestUserId = requestUserId;
-      }
-      if (requesterType) {
-        meta.requesterType = requesterType;
-      }
-
-      await axios.post(
-        logServiceUrl,
-        {
-          service: serviceName,
-          level,
-          message,
-          meta,
-          timestamp: new Date().toISOString(),
-        },
-        { timeout: 2000 }
-      );
-    } catch (err) {
-      // Only warn locally, don’t crash
-      logger.warn({ err }, "Failed to send log to remote service");
-    }
-  };
-
-  const logWrapper: Logger = {
-    info: (msg: string, meta?: LogMeta) => {
-      logger.info(meta, msg);
-      sendLog("info", msg, meta);
-    },
-    error: (msg: string, meta?: LogMeta) => {
-      logger.error(meta, msg);
-      sendLog("error", msg, meta);
-    },
-    warn: (msg: string, meta?: LogMeta) => {
-      logger.warn(meta, msg);
-      sendLog("warn", msg, meta);
-    },
-    debug: (msg: string, meta?: LogMeta) => {
-      logger.debug(meta, msg);
-      sendLog("debug", msg, meta);
-    },
-    setRequest: (requesterId: string | null, url: string | null, method: string | null, userId: string | null, type: 'user' | 'internal' | null) => {
-      requestId = requesterId;
-      requestURL = url;
-      requestMethod = method;
-      requestUserId = userId;
-      requesterType = type;
-    }
-  };
-
-  return logWrapper;
-}
-
-export type { LoggerOptions, LogMeta };