ztechno_core 0.0.105 → 0.0.108

package/lib/core/types/crypto_types.d.ts

@@ -0,0 +1,4 @@
+export type HashStruct = {
+  iv: string;
+  encryptedData: string;
+};

package/lib/core/types/crypto_types.js

@@ -0,0 +1,2 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });

package/lib/core/types/mail_types.d.ts

@@ -0,0 +1,95 @@
+import SMTPTransport from 'nodemailer/lib/smtp-transport';
+import { Attachment } from 'nodemailer/lib/mailer';
+import { ZSQLService } from '../sql_service';
+export type MailAttachment = Attachment;
+interface OptionalOptions {
+  cacheDir?:
+    | string
+    | false
+    | undefined /** optional location for cached messages. If not set then caching is not used. */;
+  cacheTreshold?:
+    | number
+    | undefined /** optional size in bytes, if message is larger than this treshold it gets cached to disk (assuming cacheDir is set and writable). Defaults to 131072 (128 kB). */;
+  hashAlgo?: string | undefined /** optional algorithm for the body hash, defaults to ‘sha256’ */;
+  headerFieldNames?:
+    | string
+    | undefined /** an optional colon separated list of header keys to sign (eg. message-id:date:from:to...') */;
+  skipFields?:
+    | string
+    | undefined /** optional colon separated list of header keys not to sign. This is useful if you want to sign all the relevant keys but your provider changes some values, ie Message-ID and Date. In this case you should use 'message-id:date' to prevent signing these values. */;
+}
+interface SingleDKIMKeyOptions extends OptionalOptions {
+  domainName: string /** is the domain name to use in the signature */;
+  keySelector: string /** is the DKIM key selector */;
+  privateKey:
+    | string
+    | {
+        key: string;
+        passphrase: string;
+      } /** is the private key for the selector in PEM format */;
+}
+export type MailResponse = SMTPTransport.SentMessageInfo;
+export type MailServiceOptions = {
+  auth: {
+    user: string;
+    pass: string;
+  };
+  mailSender: string;
+  dkim?: SingleDKIMKeyOptions;
+  sqlService: ZSQLService;
+  hashSalt?: string;
+  dirTemplate?: string;
+  baseInject?: {
+    logoSrc?: string;
+    baseUrl?: string;
+    title: string;
+    content: string;
+  };
+};
+export type MailOptionsBase = {
+  recipient: string;
+  subject: string;
+  from?: string;
+  priority?: 'high' | 'normal' | 'low';
+  dkim?: SingleDKIMKeyOptions;
+  attachments?: MailAttachment[];
+};
+export type MailOptionsText = MailOptionsBase & {
+  body: string;
+};
+export type MailOptionsHtml = MailOptionsBase & {
+  html: string;
+};
+export type MailOptions = MailOptionsBase & {
+  body?: string;
+  html?: string;
+};
+export type ZMailSendOptTemplate = MailOptionsBase & {
+  template: 'C:/example/template.html' | string;
+  inject: {
+    title: string;
+    content: string;
+  } & {
+    [key: string]: string | number;
+  };
+};
+export type ZMailSendOptAll = MailOptionsBase & {
+  body: string;
+  html: string;
+  template: 'C:/example/template.html' | string;
+  inject: {
+    title: string;
+    content: string;
+  } & {
+    [key: string]: string | number;
+  };
+};
+export type ZMailBlacklist = {
+  email: string;
+  hash?: string;
+  is_blacklisted: 0 | 1 | boolean;
+  updated_at: string;
+  created_at: string;
+};
+export type ZMailBlacklistSearch = Pick<ZMailBlacklist, 'email' | 'is_blacklisted'>;
+export {};

package/lib/core/types/mail_types.js

@@ -0,0 +1,2 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });

package/lib/core/types/site_config.d.ts

@@ -0,0 +1,46 @@
+export type Coordinates = [number, number];
+export type CompanyInfo = {
+  baseUrl: string;
+  website: string;
+  company: string;
+  copyright: string;
+  kvk: string;
+  kvkUrl: string;
+  btwNr: string;
+  iban: string;
+  bankName: string;
+};
+export type Address = {
+  street: string;
+  city: string;
+  zipcode: string;
+  addressRegion: string;
+  country: string;
+  latLng: Coordinates;
+};
+export type ContactInfo = {
+  phone: string;
+  contact: string;
+  contactQuote: string;
+  mapsUrl: string;
+  whatsappUrl: string;
+};
+export type SeoDefaults = {
+  keywords: string;
+  description: string;
+  ogLocale: string;
+};
+export type RenderContext = {
+  startTimeStamp: number;
+  path: string;
+  ejsPath: string;
+  isProd: boolean;
+  projectsHtml: string;
+};
+export type RenderData = {
+  company: CompanyInfo;
+  address: Address;
+  contact: ContactInfo;
+  seo: SeoDefaults;
+  context: RenderContext;
+};

package/lib/core/types/site_config.js

@@ -0,0 +1,2 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });

package/lib/core/types/translate_types.d.ts

@@ -0,0 +1,69 @@
+import { ZSQLService } from '../sql_service';
+export type Dom = {} & Node;
+export type Node = {
+  getAttribute: (attr: string) => string;
+  getElementsByTagName: (tag: string) => Node[];
+  getElementsByClassName: (cls: string) => Node[];
+  getElementById: (id: string) => Node;
+  getElementsByName: (name: string) => Node[];
+  nodeType: string;
+  nodeName: string;
+  childNodes: Node[];
+  firstChild: Node;
+  lastChild: Node;
+  parentNode: Node;
+  attributes: any[];
+  innerHTML: string;
+  outerHTML: string;
+  textContent: string;
+  text: string;
+};
+export type ZNodeText = {
+  text: string;
+} & Node;
+export type TranslateData = {
+  value: string;
+  meta?: {
+    prefix: string;
+    suffix: string;
+  };
+};
+export type dbTranslationRow = {
+  lang: string;
+  key: string;
+  value: string;
+};
+export type ATranslateLang = {
+  lang: string;
+  text: string;
+};
+export type TranslateServiceOptions = {
+  sqlService: ZSQLService;
+  googleApiKey: string;
+  languages?: ATranslateLang[];
+  defaultLang?: string;
+  sourceLang?: string;
+  surpressErrors?: boolean;
+  log?: (data: any, context: any) => any;
+  verbose?: (data: any, context: any) => any;
+  maxRetries?: number;
+  retryDelay?: number;
+  fallbackText?: string;
+};
+export declare class TranslateError extends Error {
+  code: string;
+  context?: any;
+  constructor(message: string, code: string, context?: any);
+}
+export declare class HtmlEntityError extends TranslateError {
+  constructor(code: string, text: string);
+}
+export declare class ApiTranslationError extends TranslateError {
+  constructor(originalError: any, text: string, lang: string);
+}
+export declare class DatabaseError extends TranslateError {
+  constructor(originalError: any, operation: string);
+}
+export declare class ValidationError extends TranslateError {
+  constructor(field: string, value: any);
+}

package/lib/core/types/translate_types.js

@@ -0,0 +1,46 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.ValidationError =
+  exports.DatabaseError =
+  exports.ApiTranslationError =
+  exports.HtmlEntityError =
+  exports.TranslateError =
+    void 0;
+// Custom error types for better error handling
+class TranslateError extends Error {
+  constructor(message, code, context) {
+    super(message);
+    this.code = code;
+    this.context = context;
+    this.name = 'TranslateError';
+  }
+}
+exports.TranslateError = TranslateError;
+class HtmlEntityError extends TranslateError {
+  constructor(code, text) {
+    super(`Cannot recognize character code="${code}" for text="${text}"`, 'HTML_ENTITY_ERROR', { code, text });
+  }
+}
+exports.HtmlEntityError = HtmlEntityError;
+class ApiTranslationError extends TranslateError {
+  constructor(originalError, text, lang) {
+    super(`Translation API failed for text="${text}" to language="${lang}"`, 'API_TRANSLATION_ERROR', {
+      originalError,
+      text,
+      lang,
+    });
+  }
+}
+exports.ApiTranslationError = ApiTranslationError;
+class DatabaseError extends TranslateError {
+  constructor(originalError, operation) {
+    super(`Database operation failed: ${operation}`, 'DATABASE_ERROR', { originalError, operation });
+  }
+}
+exports.DatabaseError = DatabaseError;
+class ValidationError extends TranslateError {
+  constructor(field, value) {
+    super(`Invalid ${field}: ${value}`, 'VALIDATION_ERROR', { field, value });
+  }
+}
+exports.ValidationError = ValidationError;

package/lib/core/types/user_types.d.ts

@@ -0,0 +1,41 @@
+export type ZUserCore = {
+  user_id: number;
+  email: string;
+  session: string;
+  role: string | null;
+  admin: 0 | 1;
+  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;
+};
+export type ZUserSession = {
+  session: string;
+};
+export type ZUserTableConfig = {
+  tableName?: string;
+  customColumns?: {
+    [columnName: string]: string;
+  };
+  customIndexes?: string[];
+};

package/lib/core/types/user_types.js

@@ -0,0 +1,2 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });

package/lib/core/user_service.d.ts

@@ -0,0 +1,87 @@
+import { ZSQLService } from './sql_service';
+import {
+  ZRequiredUserColumns,
+  ZUser,
+  ZUserCore,
+  ZUserSession,
+  ZUserCredentials,
+  ZUserTableConfig,
+} from './types/user_types';
+/**
+ * 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,
+> {
+  protected tableName: string;
+  protected sqlService: ZSQLService;
+  protected tableConfig: ZUserTableConfig;
+  private salt;
+  /**
+   * 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>;
+  protected createTable(): Promise<void>;
+  ensureTableExists(): Promise<void>;
+  /**
+   * 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;
+  }>;
+  /**
+   * Gets all available columns for SELECT queries
+   * @returns Comma-separated list of column names
+   * @protected
+   */
+  protected getSelectColumns(): string;
+  find(
+    opt:
+      | {
+          email: string;
+        }
+      | {
+          user_id: number;
+        },
+  ): Promise<TUser | undefined>;
+  auth(opt: ZUserSession | ZUserCredentials): Promise<{
+    user?: TUser;
+    session?: string;
+    authenticated: boolean;
+  }>;
+  fetch(opt?: { limit?: number }): Promise<TUser[]>;
+  private genSession;
+  private hashPass;
+}

package/lib/core/user_service.js

@@ -0,0 +1,216 @@
+'use strict';
+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 {
+  /**
+   * Creates a new ZUserService instance
+   * @param options - Configuration options including SQL service and optional table configuration
+   */
+  constructor({ sqlService, tableConfig }) {
+    this.sqlService = sqlService;
+    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
+      WHERE table_schema = '${this.sqlService.database}' AND table_name = '${this.tableName}'
+      LIMIT 1
+    `);
+    return res.length > 0;
+  }
+  async checkTableHasAdmin() {
+    const res = await this.sqlService.query(`
+      SELECT user_id FROM \`${this.tableName}\` WHERE admin=1
+    `);
+    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}\` (
+        ${allColumns},
+        ${allIndexes}
+      ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
+    `);
+  }
+  async ensureTableExists() {
+    const exists = await this.checkTableExists();
+    if (!exists) {
+      await this.createTable();
+    }
+  }
+  /**
+   * 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}\` (${fieldNames})
+      VALUES (${placeholders})
+    `,
+      values,
+    );
+    return { session };
+  }
+  /**
+   * 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.fetch({
+        Query: /*SQL*/ `
+          SELECT ${selectColumns} FROM \`${this.tableName}\`
+          WHERE email=:email
+        `,
+        Params: { email: opt.email },
+      });
+      return rows[0];
+    } else if (opt.user_id !== undefined) {
+      const rows = await this.sqlService.fetch({
+        Query: /*SQL*/ `
+          SELECT ${selectColumns} FROM \`${this.tableName}\`
+          WHERE user_id=:user_id
+        `,
+        Params: { user_id: opt.user_id },
+      });
+      return rows[0];
+    } else {
+      throw new Error(`Unexpected Input for ZUserService.find(${JSON.stringify(opt)})`);
+    }
+  }
+  async auth(opt) {
+    if (!opt.session && !opt.email && !opt.pass) {
+      return { authenticated: false };
+    }
+    const selectColumns = this.getSelectColumns();
+    const res = await (opt.session
+      ? this.sqlService.fetch({
+          Query: /*SQL*/ `
+        SELECT ${selectColumns} FROM \`${this.tableName}\` WHERE session=?
+      `,
+          Params: [opt.session],
+        })
+      : this.sqlService.fetch({
+          Query: /*SQL*/ `
+        SELECT ${selectColumns} FROM \`${this.tableName}\` WHERE email=? AND pass=?
+      `,
+          Params: [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.fetch(
+      `
+      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();
+    return crypto_service_1.ZCryptoService.hash('sha256', data, { saltMode: 'simple', salt });
+  }
+  hashPass({ email, pass }) {
+    const salt = email + this.salt;
+    return crypto_service_1.ZCryptoService.hash('sha256', pass, { saltMode: 'simple', salt });
+  }
+}
+exports.ZUserService = ZUserService;

package/lib/express/index.d.ts

@@ -0,0 +1 @@
+export declare function middleware(): (req: Express.Request, res: Express.Response, next: any) => Promise<any>;

package/lib/express/index.js

@@ -0,0 +1,18 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.middleware = void 0;
+function middleware() {
+  return async (req, res, next) => {
+    if (req.cookies === undefined) {
+      throw new Error(`Module 'cookie-parser' isn't initialized. Please use app.use(cookieParser())`);
+    }
+    if (req.cookies.session === undefined) {
+      return next();
+    }
+    const auth = await userService.auth({ session: req.cookies?.session });
+    req.user = auth.user;
+    // TODO: Implement assertAdmin or something like that
+    next();
+  };
+}
+exports.middleware = middleware;

package/lib/index.d.ts

@@ -1,10 +1,19 @@
-import { ZEngineBase } from './engine_base';
-import { ZCryptoService } from './crypto_service';
-import { ZMailService } from './mail_service';
-import { ZSQLService } from './sql_service';
-import { ZTranslateService } from './translate_service';
-import { ZUserService } from './user_service';
+export {
+  ZEngineBase,
+  ZCryptoService,
+  ZMailService,
+  ZSQLService,
+  ZTranslateService,
+  ZUserService,
+  ZOrm,
+  ZMailBlacklistOrm,
+} from './core';
+export * from './core/types/crypto_types';
+export * from './core/types/mail_types';
+export * from './core/types/translate_types';
+export * from './core/types/user_types';
+export * from './core/types/site_config';
+export { InvoiceService, CustomerService, MollieService, SubscriptionService } from './mollie';
+export * from './mollie/types/mollie_types';
 export { middleware } from './express';
-export * from './typings';
 export * from './schema';
-export { ZEngineBase, ZCryptoService, ZMailService, ZSQLService, ZTranslateService, ZUserService };