lupine.api 1.0.41

package/src/lang/lang-helper.ts

@@ -0,0 +1,76 @@
+import { deepMerge, Logger } from '../lib';
+import { apiLangEn } from './api-lang-en';
+import { LangProps, OneLangProps } from './lang-props';
+import { apiCache } from '../api';
+import { apiLangZhCn } from './api-lang-zh-cn';
+
+/*
+This module only provides server-side multi-language support.
+
+language code: https://www.andiamo.co.uk/resources/iso-language-codes/
+English: en, Chinese (PRC): zh-cn, Chinese (Hong Kong): zh-hk, Chinese (Taiwan): zh-tw, Japanese: ja, Korean: ko
+
+
+Multi-language reason:
+This framework may be used for Chinese or English projects, but to keep only one code, the underlying framework needs to return messages, pages, and other content when called.
+Before the call, a message list needs to be set up. The underlying framework returns the message corresponding to the language based on the key.
+*/
+export class LangHelper {
+  private static instance: LangHelper;
+  private logger = new Logger('lang-helper');
+  private langs: LangProps = {};
+
+  private constructor() {
+    this.addLang(apiLangEn);
+    this.addLang(apiLangZhCn);
+  }
+
+  public static getInstance(): LangHelper {
+    if (!LangHelper.instance) {
+      LangHelper.instance = new LangHelper();
+    }
+    return LangHelper.instance;
+  }
+
+  // 'My name is {name}' -> getLang('my_name_is', { name: 'John' })
+  public getLang(key: string, params?: { [key: string]: string | number | boolean }) {
+    return this.getLangWithLangName(key, apiCache.getLang(), '', params);
+  }
+
+  public getLangWithLangName(
+    key: string,
+    langName = '',
+    defaultLang = '',
+    params?: { [key: string]: string | number | boolean }
+  ) {
+    if (!langName) {
+      // if lang is not set, this should be called in a request
+      langName = apiCache.getLang();
+    }
+    const oneLang = this.langs[langName];
+    if (!oneLang || !oneLang.langs[key]) {
+      this.logger.warn(`Lang not found: ${langName}`);
+      return defaultLang || `${key} (Lang not found)`;
+    }
+    if (params) {
+      return oneLang.langs[key].replace(/\{(\w+)\}/g, (match, name) => {
+        return (params[name] || match).toString();
+      });
+    }
+    return oneLang.langs[key];
+  }
+
+  public getLangs() {
+    return this.langs;
+  }
+
+  // Sub projects can extend or override the language set
+  public addLang(lang: OneLangProps) {
+    if (!this.langs[lang.langName]) {
+      this.langs[lang.langName] = { langName: lang.langName, langs: {} };
+    }
+    deepMerge(this.langs[lang.langName], lang);
+  }
+}
+
+export const langHelper = /* @__PURE__ */ LangHelper.getInstance();

package/src/lang/lang-props.ts

@@ -0,0 +1,6 @@
+export type OneLangProps = {
+  langName: string;
+  langs: { [key: string]: string };
+};
+
+export type LangProps = { [key: string]: OneLangProps };

package/src/lib/db/db-helper.ts

@@ -0,0 +1,23 @@
+import { Logger } from '../logger';
+import { Db } from './db';
+import { DbConfig } from '../../models/db-config';
+import { DbSqlite } from './db-sqlite';
+
+const logger = new Logger('db-helper');
+export class DbHelper {
+  static async createInstance(option: DbConfig): Promise<Db> {
+    if (!option || !option.type) {
+      throw new Error('Invalid configuration');
+    }
+
+    const type = option.type.toLowerCase();
+    switch (type) {
+      case 'sqlite':
+        const db = new DbSqlite(option);
+        await db.connect();
+        return db;
+      default:
+        throw new Error(`Unsupported database type: ${type}`);
+    }
+  }
+}

package/src/lib/db/db-mysql.ts

@@ -0,0 +1,250 @@
+/*
+npm install mysql2
+npm install --save-dev @types/mysql2
+
+*/
+import { createPool, Pool, PoolConnection, RowDataPacket, OkPacket, ResultSetHeader } from 'mysql2/promise';
+import { Logger } from '../logger';
+import { Db } from './db';
+import { DbConfig } from '../../models/db-config';
+
+/**
+connection = mysql.createConnection({
+  host : 'localhost',
+  user : '***',
+  password : '***',
+  port : 3306,
+  database: '***',
+  insecureAuth: true,
+  //debug: true,
+});
+connection.connect();
+
+connection.end();
+
+    getConn: function (config) {
+      config.host = config.host || "localhost";
+      config.port = config.port || 3306;
+      connection = mysql.createConnection({
+        host: config.host,
+        user: config.user,
+        password: config.password,
+        port: config.port,
+        database: config.database,
+        insecureAuth: config.insecureAuth,
+        debug: config.debug,
+      });
+      connection.connect();
+
+      this.debug = config.debug || false;
+      var thisObj = this;
+      connection.on("error", function (err) {
+        if (!err.fatal) {
+          return;
+        }
+
+        if (err.code !== "PROTOCOL_CONNECTION_LOST") {
+          throw err;
+        }
+
+        //console.log('Re-connecting lost connection: ' + err.stack);
+        console.log("Re-connecting lost connection: " + err);
+        thisObj.connection = thisObj.getConn(config);
+      });
+      this.connection = connection;
+      return connection;
+    },
+
+    query: function (cb, sql) {
+      try {
+        var conn = this.connection;
+        sql = this.replacePrefix(sql);
+        console.log("query:" + sql);
+        conn.query(sql, cb);
+      } catch (err) {
+        console.log(err);
+        if (err.code == "PROTOCOL_CONNECTION_LOST") {
+          var conn = this.connection;
+          conn.query(sql, cb);
+        } else {
+          cb(err, false);
+        }
+      }
+      return true;
+    },
+
+    escape: function (val) {
+      return mysql.escape(val);
+    },
+
+    escapeId: function (id) {
+      return mysql.escapeId(id);
+    },
+
+*/
+
+
+const logger = new Logger('db-mysql');
+
+export class DbMysql extends Db {
+  private pool!: Pool;
+  private connection!: PoolConnection;
+
+  constructor(option: DbConfig) {
+    super(option);
+    
+    this.pool = createPool({
+      host: option.host || 'localhost',
+      user: option.user,
+      password: option.password,
+      database: option.database,
+      port: option.port || 3306,
+      /* Math.max(2, Math.floor(10 / numCPUs)); */
+      connectionLimit: 2,
+      waitForConnections: true,
+      queueLimit: 0,
+      namedPlaceholders: true,
+      supportBigNumbers: true,
+      bigNumberStrings: true,
+      // Enable for debugging
+      // debug: logger.isDebug()
+    });
+
+    // Test the connection
+    if (logger.isDebug()) {
+      this.testConnection();
+    }
+  }
+
+  async close() {
+    if (this.pool) {
+      await this.pool.end();
+    }
+  }
+
+  async connect() {
+    try {
+      this.connection = await this.pool.getConnection();
+      return Promise.resolve();
+    } catch (error: any) {
+      logger.error('Failed to connect to MySQL:', error);
+      return Promise.reject(error);
+    }
+  }
+
+  public async nativeQuery(sql: string, params?: any, isSelect: boolean = true): Promise<any> {
+    let connection: PoolConnection | null = null;
+    
+    try {
+      connection = await this.pool.getConnection();
+      
+      if (logger.isDebug()) {
+        logger.debug('Executing query:', { sql, params });
+      }
+
+      let result: any;
+      
+      if (isSelect) {
+        const [rows] = await connection.execute<RowDataPacket[]>(sql, params);
+        result = rows;
+      } else {
+        const [resultSet] = await connection.execute<ResultSetHeader>(sql, params);
+        // For INSERT, UPDATE, DELETE operations, return the result set
+        result = [resultSet];
+      }
+
+      if (logger.isDebug()) {
+        logger.debug('Query result:', { sql, rowCount: Array.isArray(result) ? result.length : 1 });
+      }
+      
+      return result;
+    } catch (error) {
+      logger.error('Error executing query:', { sql, params, error });
+      throw error;
+    } finally {
+      if (connection) {
+        connection.release();
+      }
+    }
+  }
+
+  public async truncateTable(tableName: string): Promise<any> {
+    // MySQL uses TRUNCATE TABLE which is more efficient than DELETE FROM
+    return this.execute(`TRUNCATE TABLE ${tableName}`);
+  }
+
+  public async getTableCount(tableName: string): Promise<number> {
+    const result = await this.select(`SELECT COUNT(*) as c FROM ${tableName}`);
+    return result[0].c;
+  }
+
+  public async getAllTables(addCount: boolean = false): Promise<any[]> {
+    const query = `
+      SELECT 
+        TABLE_NAME as name,
+        TABLE_SCHEMA as schema_name,
+        TABLE_TYPE as type,
+        ENGINE as engine,
+        TABLE_ROWS as row_count,
+        DATA_LENGTH as data_length,
+        INDEX_LENGTH as index_length,
+        CREATE_TIME as create_time,
+        UPDATE_TIME as update_time
+      FROM 
+        information_schema.TABLES 
+      WHERE 
+        TABLE_SCHEMA = DATABASE()
+    `;
+    
+    const result = await this.select(query);
+    
+    if (result && addCount) {
+      for (const table of result) {
+        try {
+          table.count = await this.getTableCount(table.name);
+        } catch (error: any) {
+          logger.error(`Error getting count for table ${table.name}:`, error);
+          table.count = -1; // Indicate error
+        }
+      }
+    }
+    
+    return result || [];
+  }
+
+  public async getTableInfo(table: string): Promise<any> {
+    const query = `
+      SELECT 
+        COLUMN_NAME as name,
+        DATA_TYPE as type,
+        IS_NULLABLE as is_nullable,
+        COLUMN_DEFAULT as default_value,
+        COLUMN_KEY as key,
+        EXTRA as extra,
+        CHARACTER_MAXIMUM_LENGTH as max_length,
+        NUMERIC_PRECISION as numeric_precision,
+        NUMERIC_SCALE as numeric_scale,
+        COLUMN_COMMENT as comment
+      FROM 
+        information_schema.COLUMNS 
+      WHERE 
+        TABLE_SCHEMA = DATABASE() 
+        AND TABLE_NAME = ?
+      ORDER BY 
+        ORDINAL_POSITION
+    `;
+    
+    return await this.select(query, [table]);
+  }
+
+  public async testConnection() {
+    try {
+      const [result] = await this.pool.query('SELECT 1 as test');
+      logger.debug('MySQL connection test successful:', result);
+      return true;
+    } catch (error: any) {
+      logger.error('MySQL connection test failed:', error);
+      return false;
+    }
+  }
+}

package/src/lib/db/db-sqlite.ts

@@ -0,0 +1,101 @@
+import Database from 'better-sqlite3';
+import { Logger } from '../logger';
+import { Db } from './db';
+import { DbConfig } from '../../models/db-config';
+
+const logger = new Logger('db-sqlite');
+export class DbSqlite extends Db {
+  db!: Database.Database;
+
+  constructor(option: DbConfig) {
+    super(option);
+
+    this.db = new Database(option.filename!, {
+      nativeBinding: 'node_modules/better-sqlite3/build/Release/better_sqlite3.node',
+    });
+    this.db.pragma('journal_mode = WAL');
+
+    if (logger.isDebug()) {
+      this.testConnection();
+    }
+  }
+
+  close() {
+    this.db.close();
+  }
+
+  connect() {
+    return Promise.resolve();
+  }
+
+  // INSERT...RETURNING is also supported in MariaDB from 10.5.0
+  public nativeQuery(sql: string, params?: any, isSelect?: boolean): Promise<any> {
+    return new Promise((resolve, reject) => {
+      try {
+        let rows: any;
+        if (isSelect) {
+          rows = params ? this.db.prepare(sql).all(params) : this.db.prepare(sql).all();
+        } else {
+          const preSql = sql.trim().substring(0, 6).toLowerCase();
+          if (preSql.startsWith('insert') || preSql.startsWith('update') || preSql.startsWith('delete')) {
+            sql = sql + ' returning *';
+          }
+          rows = params ? this.db.prepare(sql).run(params) : this.db.prepare(sql).run();
+          if (rows && typeof rows.length === 'undefined') {
+            // sqlite3 returns id as a record
+            rows = [
+              {
+                ...rows,
+                id: rows.changes > 0 ? rows.lastInsertRowid : undefined,
+              },
+            ];
+          }
+        }
+
+        if (logger.isDebug()) {
+          console.log('query:', sql, ', params:', params, ', result:', rows && rows.length);
+        }
+        resolve(rows);
+      } catch (err) {
+        console.error('query:', sql, ', params:', params, ', error:', err);
+        reject(err);
+      }
+    });
+  }
+
+  public async truncateTable(tableName: string): Promise<any> {
+    // sqlite doesn't have DROP command
+    return this.execute(`DELETE FROM ${tableName}`);
+  }
+
+  // public async createTable(table: string, fields: string[]) {
+  //   // table = this.replacePrefix(table);
+  //   const query = 'CREATE TABLE ' + table + ' (' + fields.join(',') + ')';
+  //   return await this.query(query);
+  // }
+
+  public async getTableCount(tableName: string) {
+    const result = await this.select(`SELECT COUNT(*) as c FROM ${tableName}`);
+    return result[0].c;
+  }
+
+  public async getAllTables(addCount = false) {
+    const query = `SELECT * FROM sqlite_master WHERE type ='table';`;
+    const result = await this.select(query);
+    if (result) {
+      if (addCount) {
+        for (let i in result) {
+          result[i].count = await this.getTableCount(result[i].tbl_name);
+        }
+      }
+      return result;
+    }
+    return false;
+  }
+
+  public async getTableInfo(table: string): Promise<any> {
+    const query = `PRAGMA table_info(${table});`;
+    const result = await this.execute(query);
+    return result;
+  }
+}

package/src/lib/db/db.spec.ts

@@ -0,0 +1,28 @@
+import { Logger } from '../logger';
+
+describe('Test logger', () => {
+  var db: any;
+  beforeEach(() => {
+    const sqlite3 = require('sqlite3').verbose();
+    db = new sqlite3.Database(':memory:');
+  });
+
+  it('test init without recreating a file', (done) => {
+    db.serialize(() => {
+      db.run('CREATE TABLE lorem (info TEXT)');
+
+      const stmt = db.prepare('INSERT INTO lorem VALUES (?)');
+      for (let i = 0; i < 10; i++) {
+        stmt.run('Ipsum ' + i);
+      }
+      stmt.finalize();
+
+      db.each('SELECT rowid AS id, info FROM lorem', (err: any, row: any) => {
+        console.log(row.id + ': ' + row.info);
+      });
+    });
+
+    db.wait(done);
+    db.close();
+  });
+});