ztechno_core 0.0.105 → 0.0.108

package/lib/core/crypto_service.d.ts

@@ -0,0 +1,23 @@
+import { HashStruct } from './types/crypto_types';
+export declare class ZCryptoService {
+  static encrypt(text: string): HashStruct;
+  static decrypt(data: HashStruct): string;
+  static decrypt(encrypted: string): string;
+  static decryptJSON<T = any>(data: HashStruct): T;
+  static decryptJSON<T = any>(data: string): T;
+  static hash(
+    hashAlgorithm: 'sha256' | 'sha512' | 'md5',
+    data: string,
+    opt?: {
+      itt?: number;
+    } & (
+      | {
+          saltMode: 'none';
+        }
+      | {
+          saltMode: 'simple';
+          salt: string;
+        }
+    ),
+  ): string;
+}

package/lib/core/crypto_service.js

@@ -0,0 +1,100 @@
+'use strict';
+var __createBinding =
+  (this && this.__createBinding) ||
+  (Object.create
+    ? function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        var desc = Object.getOwnPropertyDescriptor(m, k);
+        if (!desc || ('get' in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+          desc = {
+            enumerable: true,
+            get: function () {
+              return m[k];
+            },
+          };
+        }
+        Object.defineProperty(o, k2, desc);
+      }
+    : function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        o[k2] = m[k];
+      });
+var __setModuleDefault =
+  (this && this.__setModuleDefault) ||
+  (Object.create
+    ? function (o, v) {
+        Object.defineProperty(o, 'default', { enumerable: true, value: v });
+      }
+    : function (o, v) {
+        o['default'] = v;
+      });
+var __importStar =
+  (this && this.__importStar) ||
+  function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null)
+      for (var k in mod)
+        if (k !== 'default' && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+  };
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.ZCryptoService = void 0;
+const crypto = __importStar(require('crypto'));
+const algorithm = 'aes-256-cbc';
+const key = Buffer.from([
+  253, 144, 73, 128, 71, 94, 34, 3, 28, 128, 194, 166, 132, 154, 14, 87, 221, 202, 92, 56, 139, 10, 38, 122, 120, 7,
+  149, 40, 211, 218, 217, 3,
+]);
+const iv = Buffer.from([0, 209, 223, 20, 147, 45, 14, 107, 93, 6, 76, 206, 176, 55, 245, 134]);
+class ZCryptoService {
+  static encrypt(text) {
+    const cipher = crypto.createCipheriv(algorithm, key, iv);
+    let encrypted = cipher.update(text);
+    encrypted = Buffer.concat([encrypted, cipher.final()]);
+    return { iv: iv.toString('hex'), encryptedData: encrypted.toString('hex') };
+  }
+  static decrypt(data) {
+    if (typeof data === 'string') {
+      const encryptedText = Buffer.from(data, 'hex');
+      const decipher = crypto.createDecipheriv(algorithm, key, iv);
+      let decrypted = decipher.update(encryptedText);
+      decrypted = Buffer.concat([decrypted, decipher.final()]);
+      return decrypted.toString();
+    }
+    const niv = Buffer.from(data.iv, 'hex');
+    const encryptedText = Buffer.from(data.encryptedData, 'hex');
+    const decipher = crypto.createDecipheriv(algorithm, key, niv);
+    let decrypted = decipher.update(encryptedText);
+    decrypted = Buffer.concat([decrypted, decipher.final()]);
+    return decrypted.toString();
+  }
+  static decryptJSON(data) {
+    try {
+      const decrypted = ZCryptoService.decrypt(data);
+      return JSON.parse(decrypted);
+    } catch (err) {
+      throw new Error(`Couldn't decrypt JSON ${JSON.stringify(data)}`);
+    }
+  }
+  static hash(hashAlgorithm, data, opt) {
+    const itt = opt?.itt || 1;
+    let salt;
+    if (opt && opt.saltMode === 'simple') {
+      salt = opt.salt;
+      data = data
+        .split('')
+        .map((c, i) => c + salt.charAt(i % salt.length))
+        .join('');
+    }
+    let hash = data;
+    for (let i = 0; i < itt; i++) {
+      hash = crypto.createHash(hashAlgorithm).update(hash).digest('hex');
+    }
+    const cut = itt.toString().length + 1;
+    hash = `${itt}$${hash.substring(cut)}`;
+    return hash;
+  }
+}
+exports.ZCryptoService = ZCryptoService;

package/lib/core/engine_base.d.ts

@@ -0,0 +1,11 @@
+import { ZMailService } from './mail_service';
+import { ZSQLService } from './sql_service';
+import { ZTranslateService } from './translate_service';
+import { ZUserService } from './user_service';
+export declare class ZEngineBase {
+  static mailService?: ZMailService;
+  static sqlService?: ZSQLService;
+  static translateService?: ZTranslateService;
+  static userService?: ZUserService;
+  protected static start(): any;
+}

package/lib/core/engine_base.js

@@ -0,0 +1,9 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.ZEngineBase = void 0;
+class ZEngineBase {
+  static start() {
+    throw new Error(`Please Override ZEngineBase`);
+  }
+}
+exports.ZEngineBase = ZEngineBase;

package/lib/core/index.d.ts

@@ -0,0 +1,14 @@
+export { ZEngineBase } from './engine_base';
+export { ZCryptoService } from './crypto_service';
+export { ZMailService } from './mail_service';
+export { ZSQLService } from './sql_service';
+export type { ZSQLOptions, ZTransaction } from './sql_service';
+export { ZTranslateService } from './translate_service';
+export { ZUserService } from './user_service';
+export * from './types/crypto_types';
+export * from './types/mail_types';
+export * from './types/translate_types';
+export * from './types/user_types';
+export * from './types/site_config';
+export { ZOrm } from './orm/orm';
+export { ZMailBlacklistOrm } from './orm/mail_blacklist_orm';

package/lib/core/index.js

@@ -0,0 +1,101 @@
+'use strict';
+var __createBinding =
+  (this && this.__createBinding) ||
+  (Object.create
+    ? function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        var desc = Object.getOwnPropertyDescriptor(m, k);
+        if (!desc || ('get' in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+          desc = {
+            enumerable: true,
+            get: function () {
+              return m[k];
+            },
+          };
+        }
+        Object.defineProperty(o, k2, desc);
+      }
+    : function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        o[k2] = m[k];
+      });
+var __exportStar =
+  (this && this.__exportStar) ||
+  function (m, exports) {
+    for (var p in m)
+      if (p !== 'default' && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+  };
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.ZMailBlacklistOrm =
+  exports.ZOrm =
+  exports.ZUserService =
+  exports.ZTranslateService =
+  exports.ZSQLService =
+  exports.ZMailService =
+  exports.ZCryptoService =
+  exports.ZEngineBase =
+    void 0;
+// Services
+var engine_base_1 = require('./engine_base');
+Object.defineProperty(exports, 'ZEngineBase', {
+  enumerable: true,
+  get: function () {
+    return engine_base_1.ZEngineBase;
+  },
+});
+var crypto_service_1 = require('./crypto_service');
+Object.defineProperty(exports, 'ZCryptoService', {
+  enumerable: true,
+  get: function () {
+    return crypto_service_1.ZCryptoService;
+  },
+});
+var mail_service_1 = require('./mail_service');
+Object.defineProperty(exports, 'ZMailService', {
+  enumerable: true,
+  get: function () {
+    return mail_service_1.ZMailService;
+  },
+});
+var sql_service_1 = require('./sql_service');
+Object.defineProperty(exports, 'ZSQLService', {
+  enumerable: true,
+  get: function () {
+    return sql_service_1.ZSQLService;
+  },
+});
+var translate_service_1 = require('./translate_service');
+Object.defineProperty(exports, 'ZTranslateService', {
+  enumerable: true,
+  get: function () {
+    return translate_service_1.ZTranslateService;
+  },
+});
+var user_service_1 = require('./user_service');
+Object.defineProperty(exports, 'ZUserService', {
+  enumerable: true,
+  get: function () {
+    return user_service_1.ZUserService;
+  },
+});
+// Types
+__exportStar(require('./types/crypto_types'), exports);
+__exportStar(require('./types/mail_types'), exports);
+__exportStar(require('./types/translate_types'), exports);
+__exportStar(require('./types/user_types'), exports);
+__exportStar(require('./types/site_config'), exports);
+// ORM
+var orm_1 = require('./orm/orm');
+Object.defineProperty(exports, 'ZOrm', {
+  enumerable: true,
+  get: function () {
+    return orm_1.ZOrm;
+  },
+});
+var mail_blacklist_orm_1 = require('./orm/mail_blacklist_orm');
+Object.defineProperty(exports, 'ZMailBlacklistOrm', {
+  enumerable: true,
+  get: function () {
+    return mail_blacklist_orm_1.ZMailBlacklistOrm;
+  },
+});

package/lib/core/mail_service.d.ts

@@ -0,0 +1,85 @@
+import {
+  MailOptions,
+  MailOptionsHtml,
+  MailOptionsText,
+  MailResponse,
+  MailServiceOptions,
+  ZMailBlacklist,
+  ZMailSendOptTemplate,
+} from './types/mail_types';
+import { ZMailBlacklistOrm } from './orm/mail_blacklist_orm';
+export declare class ZMailService {
+  private opt;
+  protected get sql(): import('./sql_service').ZSQLService;
+  protected blacklistOrm: ZMailBlacklistOrm;
+  protected blacklist: ZMailBlacklist[];
+  /**
+   * Creates a new ZMailService instance
+   * @param opt - Configuration options for the mail service including authentication, sender email, and SQL service
+   */
+  constructor(opt: MailServiceOptions);
+  updateBlacklist(opt: Pick<ZMailBlacklist, 'email' | 'is_blacklisted' | 'hash'>): Promise<void>;
+  /**
+   * Refreshes the email blacklist from the database
+   * @returns Promise that resolves when the blacklist has been refreshed
+   */
+  protected refreshBlacklist(): Promise<void>;
+  /**
+   * Fetches the content of a template file from the filesystem
+   * @param template - Path to the template file to read
+   * @returns Promise that resolves to the template content as a string
+   * @throws Will throw an error if the file cannot be read
+   * @private
+   */
+  private fetchTemplate;
+  /**
+   * Checks if an email is allowed to be sent by verifying it's not blacklisted
+   * @param mailOpts - Mail options containing the recipient email to check
+   * @returns Promise that resolves to true if email is allowed, false if blacklisted
+   * @protected
+   */
+  protected allowSend(mailOpts: MailOptions): Promise<boolean>;
+  /**
+   * Sends an email with text content
+   * @param mailOpts - Mail options with text body
+   * @returns Promise that resolves to mail response or undefined if sending is not allowed
+   */
+  send(mailOpts: MailOptionsText): Promise<MailResponse | undefined>;
+  /**
+   * Sends an email with HTML content
+   * @param mailOpts - Mail options with HTML body
+   * @returns Promise that resolves to mail response or undefined if sending is not allowed
+   */
+  send(mailOpts: MailOptionsHtml): Promise<MailResponse | undefined>;
+  /**
+   * Sends an advanced email with text content, supporting templates and variable injection
+   * @param mailOpts - Mail options with text body
+   * @returns Promise that resolves to mail response
+   */
+  sendAdvanced(mailOpts: MailOptionsText): Promise<any>;
+  /**
+   * Sends an advanced email with HTML content, supporting templates and variable injection
+   * @param mailOpts - Mail options with HTML body
+   * @returns Promise that resolves to mail response
+   */
+  sendAdvanced(mailOpts: MailOptionsHtml): Promise<any>;
+  /**
+   * Sends an advanced email using a template file, supporting variable injection
+   * @param mailOpts - Mail options with template path and injection variables
+   * @returns Promise that resolves to mail response
+   */
+  sendAdvanced(mailOpts: ZMailSendOptTemplate): Promise<any>;
+  /**
+   * Injects variables into a body string by replacing placeholder tokens
+   * @param body - The string content where variables should be injected
+   * @param inject - Object containing key-value pairs where keys are variable names and values are replacement content
+   * @returns Promise that resolves to the body string with all variables injected
+   * @example
+   * ```typescript
+   * const result = await inject('Hello :name from :company', { name: 'John', company: 'ACME' });
+   * // Returns: 'Hello John from ACME'
+   * ```
+   * @private
+   */
+  private inject;
+}

package/lib/core/mail_service.js

@@ -0,0 +1,156 @@
+'use strict';
+var __importDefault =
+  (this && this.__importDefault) ||
+  function (mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.ZMailService = void 0;
+const nodemailer_1 = __importDefault(require('nodemailer'));
+const fs_1 = __importDefault(require('fs'));
+const promises_1 = __importDefault(require('fs/promises'));
+const path_1 = __importDefault(require('path'));
+const mail_blacklist_orm_1 = require('./orm/mail_blacklist_orm');
+class ZMailService {
+  get sql() {
+    return this.opt.sqlService;
+  }
+  /**
+   * Creates a new ZMailService instance
+   * @param opt - Configuration options for the mail service including authentication, sender email, and SQL service
+   */
+  constructor(opt) {
+    this.opt = opt;
+    this.blacklist = [];
+    this.blacklistOrm = new mail_blacklist_orm_1.ZMailBlacklistOrm(opt);
+    this.opt.dirTemplate = path_1.default.isAbsolute(this.opt.dirTemplate || '')
+      ? this.opt.dirTemplate
+      : path_1.default.join(process.cwd(), this.opt.dirTemplate || '');
+  }
+  async updateBlacklist(opt) {
+    const newItem = await this.blacklistOrm.upsert(opt);
+    const found = this.blacklist.find((item) => item.email === opt.email);
+    if (found) {
+      found.is_blacklisted = opt.is_blacklisted;
+      return;
+    }
+    this.blacklist.push(newItem);
+    return;
+  }
+  /**
+   * Refreshes the email blacklist from the database
+   * @returns Promise that resolves when the blacklist has been refreshed
+   */
+  async refreshBlacklist() {
+    this.blacklist = await this.blacklistOrm.findAll();
+  }
+  /**
+   * Fetches the content of a template file from the filesystem
+   * @param template - Path to the template file to read
+   * @returns Promise that resolves to the template content as a string
+   * @throws Will throw an error if the file cannot be read
+   * @private
+   */
+  async fetchTemplate(template) {
+    const filepath = path_1.default.join(this.opt.dirTemplate, template);
+    if (fs_1.default.existsSync(filepath)) {
+      return await promises_1.default.readFile(filepath, { encoding: 'utf-8' });
+    }
+    throw new Error(`Template file not found: ${filepath}`);
+  }
+  /**
+   * Checks if an email is allowed to be sent by verifying it's not blacklisted
+   * @param mailOpts - Mail options containing the recipient email to check
+   * @returns Promise that resolves to true if email is allowed, false if blacklisted
+   * @protected
+   */
+  async allowSend(mailOpts) {
+    const blacklistEntry = await this.blacklistOrm.findOne({ email: mailOpts.recipient, is_blacklisted: 1 });
+    if (blacklistEntry) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Sends an email with either text or HTML content
+   * @param mailOpts - Mail options containing recipient, subject, and body/html content
+   * @returns Promise that resolves to mail response or undefined if sending is not allowed
+   */
+  async send(mailOpts) {
+    const allow = await this.allowSend(mailOpts);
+    if (!allow) {
+      return;
+    }
+    const mailTransporter = nodemailer_1.default.createTransport({
+      service: 'gmail',
+      auth: this.opt.auth,
+    });
+    const mailDetails = {
+      from: mailOpts.from || this.opt.mailSender,
+      to: mailOpts.recipient,
+      subject: mailOpts.subject,
+      text: mailOpts.body || undefined,
+      html: mailOpts.html || undefined,
+      dkim: mailOpts.dkim ?? this.opt.dkim,
+      priority: mailOpts.priority,
+      attachments: mailOpts.attachments,
+    };
+    return await new Promise((resolve, reject) => {
+      mailTransporter.sendMail(mailDetails, function (err, data) {
+        return err ? reject(err) : resolve(data);
+      });
+    });
+  }
+  /**
+   * Sends an advanced email with enhanced features including template loading and variable injection.
+   * Automatically generates unsubscribe hash and injects common variables like email and hashToUnsubscribe.
+   * @param mailOpts - Mail options that can include template path, injection variables, and standard mail fields
+   * @returns Promise that resolves to mail response from the underlying send method
+   * @example
+   * ```typescript
+   * await mailService.sendAdvanced({
+   *   recipient: 'user@example.com',
+   *   subject: 'Welcome!',
+   *   template: './templates/welcome.html',
+   *   inject: { name: 'John', company: 'ACME Corp' }
+   * });
+   * ```
+   */
+  async sendAdvanced(mailOpts) {
+    const opts = mailOpts;
+    const hashToUnsubscribe = await this.blacklistOrm.genEmailUnsubscribeHash({ email: mailOpts.recipient });
+    if (opts.template !== undefined) {
+      opts.html = await this.fetchTemplate(opts.template);
+    }
+    if (opts.inject !== undefined) {
+      const key = opts.html !== undefined ? 'html' : 'body';
+      const baseInject = Object.assign({ email: mailOpts.recipient, hashToUnsubscribe }, this.opt.baseInject ?? {});
+      opts[key] = await this.inject(opts[key], Object.assign(baseInject, opts.inject));
+    }
+    return await this.send(opts);
+  }
+  /**
+   * Injects variables into a body string by replacing placeholder tokens
+   * @param body - The string content where variables should be injected
+   * @param inject - Object containing key-value pairs where keys are variable names and values are replacement content
+   * @returns Promise that resolves to the body string with all variables injected
+   * @example
+   * ```typescript
+   * const result = await inject('Hello :name from :company', { name: 'John', company: 'ACME' });
+   * // Returns: 'Hello John from ACME'
+   * ```
+   * @private
+   */
+  async inject(body, inject) {
+    // Sort variable names by length (longest first) to prevent partial matches
+    const sortedKeys = Object.keys(inject ?? {}).sort((a, b) => b.length - a.length);
+    sortedKeys.forEach((variableName) => {
+      const key = `:${variableName}`;
+      while (body.indexOf(key) !== -1) {
+        body = body.replace(key, inject[variableName].toString());
+      }
+    });
+    return body;
+  }
+}
+exports.ZMailService = ZMailService;

package/lib/core/orm/mail_blacklist_orm.d.ts

@@ -0,0 +1,21 @@
+import { ZOrm } from './orm';
+import { ZSQLService } from '../sql_service';
+import { ZMailBlacklist, ZMailBlacklistSearch } from '../types/mail_types';
+export declare class ZMailBlacklistOrm extends ZOrm {
+  private hashSalt;
+  constructor(opt: { sqlService: ZSQLService; alias?: string; hashSalt?: string });
+  genEmailUnsubscribeHash({ email }: { email: string }): Promise<string>;
+  create(
+    item: Omit<ZMailBlacklist, 'updated_at' | 'created_at'>,
+  ): Promise<Omit<ZMailBlacklist, 'updated_at' | 'created_at'>>;
+  findOne(conditions: Partial<ZMailBlacklist>): Promise<ZMailBlacklist>;
+  findAll(
+    conditions?: Partial<ZMailBlacklistSearch>,
+    opt?: {
+      limit?: number;
+    },
+  ): Promise<ZMailBlacklist[]>;
+  update({ email, is_blacklisted }: Pick<ZMailBlacklist, 'email' | 'is_blacklisted'>): Promise<boolean>;
+  upsert(item: Omit<ZMailBlacklist, 'updated_at' | 'created_at'>): Promise<ZMailBlacklist>;
+  createTable(): Promise<void>;
+}

package/lib/core/orm/mail_blacklist_orm.js

@@ -0,0 +1,79 @@
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.ZMailBlacklistOrm = void 0;
+const orm_1 = require('./orm');
+const crypto_service_1 = require('../crypto_service');
+class ZMailBlacklistOrm extends orm_1.ZOrm {
+  constructor(opt) {
+    super({ sqlService: opt.sqlService, alias: opt.alias ?? 'email_blacklist' });
+    this.sqlService = opt.sqlService;
+    this.hashSalt = opt.hashSalt ?? 'ZTECHNO';
+  }
+  async genEmailUnsubscribeHash({ email }) {
+    const existingHash = await this.findOne({ email });
+    if (existingHash !== undefined) {
+      return existingHash.hash;
+    }
+    const hash = crypto_service_1.ZCryptoService.hash('sha512', `${this.hashSalt}-${email}`);
+    await this.create({ email, hash, is_blacklisted: 0 });
+    return hash;
+  }
+  async create(item) {
+    const res = await this.sqlService.query(
+      `
+      INSERT INTO \`${this.alias}\` (email, hash, is_blacklisted, updated_at, created_at)
+      VALUES (:email, :hash, :is_blacklisted, NOW(), NOW())
+      ON DUPLICATE KEY UPDATE hash=:hash, updated_at=NOW()
+    `,
+      item,
+    );
+    return item; // return Object.assign(item, { invoice_id: res.insertId }) as ZMailBlacklist
+  }
+  async findOne(conditions) {
+    const rows = await this.findAll(conditions, { limit: 1 });
+    return rows[0];
+  }
+  async findAll(conditions, opt) {
+    const whereKeys = Object.keys(conditions ?? {});
+    const whereClause = whereKeys.length ? `WHERE ${whereKeys.map((key) => `${key}=:${key}`).join(' AND ')}` : '';
+    const limit = opt?.limit ? `LIMIT ${opt.limit}` : '';
+    return await this.sqlService.exec({
+      query: /*SQL*/ `SELECT * FROM \`${this.alias}\` ${whereClause} ${limit}`,
+      params: conditions,
+    });
+  }
+  async update({ email, is_blacklisted }) {
+    const res = await this.sqlService.query(
+      `
+      UPDATE \`${this.alias}\` SET is_blacklisted=:is_blacklisted, updated_at=NOW() WHERE email=:email
+    `,
+      { email, is_blacklisted },
+    );
+    return res.affectedRows !== 0;
+  }
+  async upsert(item) {
+    await this.sqlService.query(
+      `
+      INSERT INTO \`${this.alias}\` (email, hash, is_blacklisted, updated_at, created_at)
+      VALUES (:email, :hash, :is_blacklisted, NOW(), NOW())
+      ON DUPLICATE KEY UPDATE hash=:hash, is_blacklisted=:is_blacklisted, updated_at=NOW()
+    `,
+      item,
+    );
+    return item;
+  }
+  async createTable() {
+    await this.sqlService.query(/*SQL*/ `
+      CREATE TABLE \`${this.alias}\` (
+        \`email\` varchar(512) NOT NULL,
+        \`hash\` varchar(256) NOT NULL,
+        \`is_blacklisted\` tinyint(1) NOT NULL DEFAULT 0,
+        \`updated_at\` datetime NOT NULL DEFAULT current_timestamp(),
+        \`created_at\` datetime NOT NULL DEFAULT current_timestamp(),
+        PRIMARY KEY (\`email\`),
+        KEY \`is_blacklisted\` (\`is_blacklisted\`)
+      ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
+    `);
+  }
+}
+exports.ZMailBlacklistOrm = ZMailBlacklistOrm;

package/lib/core/orm/orm.d.ts

@@ -0,0 +1,27 @@
+import { ZSQLService } from '../sql_service';
+/**
+ * Safely converts a value to a JSON string for storage in a JSON column.
+ * Prevents the mysql driver from expanding plain objects into `key`=value pairs.
+ */
+export declare function toJsonColumn(value: any): string | null;
+/**
+ * Converts an ISO 8601 date string (e.g. from Mollie API) to MySQL DATETIME format.
+ * Accepts `2026-02-26T00:47:04+00:00` → `2026-02-26 00:47:04`
+ */
+export declare function toDatetime(value: string | null | undefined): string | null;
+/**
+ * Converts a Date object to MySQL DATETIME format.
+ */
+export declare function formatDatetime(value: Date): string;
+/**
+ * Converts a date-only string (e.g. `2026-02-26`) to MySQL DATETIME format.
+ */
+export declare function toDatetimeFromDateOnly(value: string | null | undefined): string | null;
+export declare class ZOrm {
+  readonly alias: string;
+  protected sqlService: ZSQLService;
+  constructor(opt: { alias: string; sqlService: ZSQLService });
+  ensureTableExists(): Promise<void>;
+  private checkTableExists;
+  createTable(): Promise<void>;
+}