ztechno_core 0.0.66 → 0.0.68

package/lib/typings/mail_types.d.ts

@@ -55,7 +55,7 @@ export type MailOptions = MailOptionsBase & {
   html?: string;
 };
 export type ZMailSendOptTemplate = MailOptionsBase & {
-  template: 'template.html';
+  template: 'C:/example/template.html' | string;
   inject: {
     title: string;
     content: string;
@@ -66,7 +66,7 @@ export type ZMailSendOptTemplate = MailOptionsBase & {
 export type ZMailSendOptAll = MailOptionsBase & {
   body: string;
   html: string;
-  template: 'template.html' | string;
+  template: 'C:/example/template.html' | string;
   inject: {
     title: string;
     content: string;

package/lib/typings/user_types.d.ts

@@ -1,4 +1,4 @@
-export type ZUser = {
+export type ZUserCore = {
   user_id: number;
   email: string;
   session: string;
@@ -7,12 +7,24 @@ export type ZUser = {
   updated_at: any;
   created_at: any;
 };
+export type ZUser = ZUserCore;
+export interface ZUserExtended extends ZUserCore {
+  username?: string;
+  first_name?: string;
+  last_name?: string;
+  avatar_url?: string;
+  bio?: string;
+  is_active?: 0 | 1;
+  email_verified?: 0 | 1;
+  last_login?: any;
+}
 export type ZRequiredUserColumns = {
   email: string;
   role: string | null;
   pass: string;
   admin: 0 | 1;
 };
+export type ZRequiredUserColumnsExtended<T = {}> = ZRequiredUserColumns & Partial<T>;
 export type ZUserCredentials = {
   email: string;
   pass: string;
@@ -20,3 +32,10 @@ export type ZUserCredentials = {
 export type ZUserSession = {
   session: string;
 };
+export type ZUserTableConfig = {
+  tableName?: string;
+  customColumns?: {
+    [columnName: string]: string;
+  };
+  customIndexes?: string[];
+};

package/lib/user_service.d.ts

@@ -1,27 +1,65 @@
 import { ZSQLService } from './sql_service';
-import { ZRequiredUserColumns, ZUser, ZUserSession, ZUserCredentials } from './typings';
-export declare class ZUserService {
+import { ZRequiredUserColumns, ZUser, ZUserCore, ZUserSession, ZUserCredentials, ZUserTableConfig } from './typings';
+/**
+ * Generic User Service that can be extended with custom user fields
+ * @template TUser - The user type (defaults to ZUser for backward compatibility)
+ * @template TUserCreate - The user creation type (defaults to ZRequiredUserColumns)
+ */
+export declare class ZUserService<
+  TUser extends ZUserCore = ZUser,
+  TUserCreate extends ZRequiredUserColumns = ZRequiredUserColumns,
+> {
   private tableName;
   private sqlService;
   private salt;
-  constructor({ sqlService, tableName }: { sqlService: ZSQLService; tableName?: string });
-  private checkTableExists;
+  protected tableConfig: ZUserTableConfig;
+  /**
+   * Creates a new ZUserService instance
+   * @param options - Configuration options including SQL service and optional table configuration
+   */
+  constructor({ sqlService, tableConfig }: { sqlService: ZSQLService; tableConfig?: ZUserTableConfig });
+  /**
+   * Gets the base table columns definition
+   * @returns SQL column definitions for core user fields
+   * @protected
+   */
+  protected getBaseTableColumns(): string;
+  /**
+   * Gets custom table columns if defined
+   * @returns SQL column definitions for custom fields
+   * @protected
+   */
+  protected getCustomTableColumns(): string;
+  /**
+   * Gets base table indexes
+   * @returns SQL index definitions for core fields
+   * @protected
+   */
+  protected getBaseTableIndexes(): string;
+  /**
+   * Gets custom table indexes if defined
+   * @returns SQL index definitions for custom fields
+   * @protected
+   */
+  protected getCustomTableIndexes(): string;
+  protected checkTableExists(): Promise<boolean>;
   checkTableHasAdmin(): Promise<boolean>;
-  private createTable;
+  protected createTable(): Promise<void>;
   ensureTableExists(): Promise<void>;
-  register({ email, pass, role, admin }: ZRequiredUserColumns): Promise<{
+  /**
+   * Registers a new user with extensible data
+   * @param userData - User data including core fields and any custom fields
+   * @returns Promise resolving to session information
+   */
+  register(userData: TUserCreate): Promise<{
     session: string;
   }>;
-  fetch(opt?: { limit: number }): Promise<any[][]>;
-  exists(
-    opt:
-      | {
-          email: string;
-        }
-      | {
-          user_id: number;
-        },
-  ): Promise<boolean>;
+  /**
+   * Gets all available columns for SELECT queries
+   * @returns Comma-separated list of column names
+   * @protected
+   */
+  protected getSelectColumns(): string;
   find(
     opt:
       | {
@@ -30,12 +68,13 @@ export declare class ZUserService {
       | {
           user_id: number;
         },
-  ): Promise<ZUser | undefined>;
+  ): Promise<TUser | undefined>;
   auth(opt: ZUserSession | ZUserCredentials): Promise<{
-    user?: ZUser;
+    user?: TUser;
     session?: string;
     authenticated: boolean;
   }>;
+  fetch(opt?: { limit?: number }): Promise<TUser[]>;
   private genSession;
   private hashPass;
 }

package/lib/user_service.js

@@ -2,12 +2,79 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 exports.ZUserService = void 0;
 const crypto_service_1 = require('./crypto_service');
+/**
+ * Generic User Service that can be extended with custom user fields
+ * @template TUser - The user type (defaults to ZUser for backward compatibility)
+ * @template TUserCreate - The user creation type (defaults to ZRequiredUserColumns)
+ */
 class ZUserService {
-  constructor({ sqlService, tableName }) {
+  /**
+   * Creates a new ZUserService instance
+   * @param options - Configuration options including SQL service and optional table configuration
+   */
+  constructor({ sqlService, tableConfig }) {
     this.sqlService = sqlService;
-    this.tableName = tableName || 'users';
+    this.tableConfig = tableConfig || {};
+    this.tableName = this.tableConfig.tableName || 'users';
     this.salt = sqlService.database;
   }
+  /**
+   * Gets the base table columns definition
+   * @returns SQL column definitions for core user fields
+   * @protected
+   */
+  getBaseTableColumns() {
+    return `
+      \`user_id\` int(10) unsigned NOT NULL AUTO_INCREMENT,
+      \`email\` varchar(255) NOT NULL,
+      \`role\` varchar(64) DEFAULT NULL,
+      \`pass\` varchar(512) NOT NULL,
+      \`session\` varchar(512) NOT NULL,
+      \`admin\` tinyint(1) NOT NULL DEFAULT 0,
+      \`updated_at\` datetime NOT NULL DEFAULT current_timestamp() ON UPDATE current_timestamp(),
+      \`created_at\` datetime NOT NULL DEFAULT current_timestamp()
+    `;
+  }
+  /**
+   * Gets custom table columns if defined
+   * @returns SQL column definitions for custom fields
+   * @protected
+   */
+  getCustomTableColumns() {
+    if (!this.tableConfig.customColumns) return '';
+    return Object.entries(this.tableConfig.customColumns)
+      .map(([columnName, definition]) => `\`${columnName}\` ${definition}`)
+      .join(',\n      ');
+  }
+  /**
+   * Gets base table indexes
+   * @returns SQL index definitions for core fields
+   * @protected
+   */
+  getBaseTableIndexes() {
+    return `
+      PRIMARY KEY (\`user_id\`),
+      UNIQUE KEY \`email_UNIQUE\` (\`email\`),
+      KEY \`email\` (\`email\`),
+      KEY \`role\` (\`role\`),
+      KEY \`admin\` (\`admin\`),
+      KEY \`created_at\` (\`created_at\`),
+      KEY \`updated_at\` (\`updated_at\`),
+      KEY \`session\` (\`session\`)
+    `;
+  }
+  /**
+   * Gets custom table indexes if defined
+   * @returns SQL index definitions for custom fields
+   * @protected
+   */
+  getCustomTableIndexes() {
+    if (!this.tableConfig.customIndexes) return '';
+    return this.tableConfig.customIndexes
+      .map((index) => index.trim())
+      .filter((index) => index.length > 0)
+      .join(',\n      ');
+  }
   async checkTableExists() {
     const res = await this.sqlService.query(`
       SELECT ENGINE, VERSION, CREATE_TIME FROM information_schema.tables
@@ -23,23 +90,17 @@ class ZUserService {
     return res.length > 0;
   }
   async createTable() {
+    const baseColumns = this.getBaseTableColumns();
+    const customColumns = this.getCustomTableColumns();
+    const baseIndexes = this.getBaseTableIndexes();
+    const customIndexes = this.getCustomTableIndexes();
+    const allColumns = customColumns ? `${baseColumns},\n      ${customColumns}` : baseColumns;
+    const allIndexes = customIndexes ? `${baseIndexes},\n      ${customIndexes}` : baseIndexes;
     await this.sqlService.query(`
       CREATE TABLE \`${this.tableName}\` (
-        \`user_id\` int(10) unsigned NOT NULL AUTO_INCREMENT,
-        \`email\` varchar(64) NOT NULL,
-        \`role\` varchar(64) DEFAULT NULL,
-        \`pass\` varchar(512) NOT NULL,
-        \`session\` varchar(512) NOT NULL,
-        \`admin\` tinyint(1) NOT NULL,
-        \`updated_at\` datetime NOT NULL DEFAULT current_timestamp(),
-        \`created_at\` datetime NOT NULL DEFAULT current_timestamp(),
-        PRIMARY KEY (\`user_id\`),
-        UNIQUE KEY \`email_UNIQUE\` (\`email\`),
-        KEY \`email\` (\`email\`),
-        KEY \`createdat\` (\`created_at\`),
-        KEY \`updatedat\` (\`updated_at\`),
-        KEY \`session\` (\`session\`)
-      ) ENGINE=InnoDB DEFAULT CHARSET=latin1 COLLATE=latin1_swedish_ci
+        ${allColumns},
+        ${allIndexes}
+      ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
     `);
   }
   async ensureTableExists() {
@@ -48,36 +109,49 @@ class ZUserService {
       await this.createTable();
     }
   }
-  async register({ email, pass, role, admin }) {
-    const session = this.genSession({ email, pass });
+  /**
+   * Registers a new user with extensible data
+   * @param userData - User data including core fields and any custom fields
+   * @returns Promise resolving to session information
+   */
+  async register(userData) {
+    const session = this.genSession({ email: userData.email, pass: userData.pass });
+    // Build dynamic SQL for insertion
+    const coreFields = ['email', 'pass', 'session', 'role', 'admin'];
+    const customFields = Object.keys(userData).filter((key) => !coreFields.includes(key) && key !== 'pass');
+    const allFields = [...coreFields, ...customFields];
+    const placeholders = allFields.map(() => '?').join(', ');
+    const fieldNames = allFields.map((field) => `\`${field}\``).join(', ');
+    const values = allFields.map((field) => {
+      if (field === 'pass') return this.hashPass({ email: userData.email, pass: userData.pass });
+      if (field === 'session') return session;
+      return userData[field];
+    });
     await this.sqlService.query(
       `
-      INSERT INTO \`${this.tableName}\` (email, pass, session, role, admin)
-      VALUES (?, ?, ?, ?, ?)
+      INSERT INTO \`${this.tableName}\` (${fieldNames})
+      VALUES (${placeholders})
     `,
-      [email, this.hashPass({ email, pass }), session, role, admin],
+      values,
     );
     return { session };
   }
-  async fetch(opt) {
-    const rows = await this.sqlService.query(
-      `
-      SELECT user_id, email, role, admin, created_at FROM \`${this.tableName}\`
-      LIMIT ?
-    `,
-      [opt.limit],
-    );
-    return rows;
-  }
-  async exists(opt) {
-    const user = await this.find(opt);
-    return user !== undefined;
+  /**
+   * Gets all available columns for SELECT queries
+   * @returns Comma-separated list of column names
+   * @protected
+   */
+  getSelectColumns() {
+    const baseColumns = ['user_id', 'email', 'session', 'role', 'admin', 'updated_at', 'created_at'];
+    const customColumns = this.tableConfig.customColumns ? Object.keys(this.tableConfig.customColumns) : [];
+    return [...baseColumns, ...customColumns].map((col) => `\`${col}\``).join(', ');
   }
   async find(opt) {
+    const selectColumns = this.getSelectColumns();
     if (opt.email !== undefined) {
       const rows = await this.sqlService.query(
         `
-        SELECT user_id, email, session, role, admin, updated_at, created_at FROM \`${this.tableName}\`
+        SELECT ${selectColumns} FROM \`${this.tableName}\`
         WHERE email=?`,
         [opt.email],
       );
@@ -85,7 +159,7 @@ class ZUserService {
     } else if (opt.user_id !== undefined) {
       const rows = await this.sqlService.query(
         `
-        SELECT user_id, email, session, role, admin, updated_at, created_at FROM \`${this.tableName}\`
+        SELECT ${selectColumns} FROM \`${this.tableName}\`
         WHERE user_id=?`,
         [opt.user_id],
       );
@@ -98,21 +172,35 @@ class ZUserService {
     if (!opt.session && !opt.email && !opt.pass) {
       return { authenticated: false };
     }
+    const selectColumns = this.getSelectColumns();
     const res = await (opt.session
       ? this.sqlService.query(
           `
-      SELECT user_id, email, session, role, admin, updated_at, created_at FROM \`${this.tableName}\`
+      SELECT ${selectColumns} FROM \`${this.tableName}\`
       WHERE session=?`,
           [opt.session],
         )
       : this.sqlService.query(
           `
-      SELECT user_id, email, session, role, admin, updated_at, created_at FROM \`${this.tableName}\`
+      SELECT ${selectColumns} FROM \`${this.tableName}\`
       WHERE email=? AND pass=?`,
           [opt.email, this.hashPass(opt)],
         ));
     return res.length === 0 ? { authenticated: false } : { user: res[0], session: res[0].session, authenticated: true };
   }
+  async fetch(opt) {
+    const selectColumns = this.getSelectColumns();
+    const limit = opt?.limit || 100;
+    const rows = await this.sqlService.query(
+      `
+      SELECT ${selectColumns} FROM \`${this.tableName}\`
+      ORDER BY created_at DESC
+      LIMIT ?
+    `,
+      [limit],
+    );
+    return rows;
+  }
   genSession({ email }) {
     const salt = this.salt;
     const data = email + Date.now() * Math.random();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ztechno_core",
-  "version": "0.0.66",
+  "version": "0.0.68",
   "description": "Core files for ztechno framework",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",