ts-prorm-orm 1.1.0

package/dist/types/index.js

@@ -0,0 +1,180 @@
+"use strict";
+/**
+ * TypeScript interfaces for the Prorm-like ORM
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryTypes = exports.IsolationLevel = exports.Transaction = exports.LockLevel = exports.ValidateOn = exports.SortDirection = exports.LoggingLevel = exports.ReferentialAction = void 0;
+// ==================== Referential Actions ====================
+/**
+ * Referential actions for foreign key constraints (onDelete / onUpdate).
+ *
+ * This enum is a companion to the existing string-literal unions used for
+ * `onDelete`/`onUpdate` fields (e.g. `'CASCADE' | 'RESTRICT' | ...`). Both
+ * forms are accepted wherever these fields appear, so existing string
+ * literals continue to work unchanged.
+ *
+ * @example
+ * ```ts
+ * import { ReferentialAction } from 'prorm';
+ *
+ * User.hasMany(Post, {
+ *   foreignKey: 'userId',
+ *   onDelete: ReferentialAction.Cascade,
+ *   onUpdate: ReferentialAction.Cascade,
+ * });
+ *
+ * // Equivalent to the string-literal form:
+ * User.hasMany(Post, {
+ *   foreignKey: 'userId',
+ *   onDelete: 'CASCADE',
+ *   onUpdate: 'CASCADE',
+ * });
+ * ```
+ */
+var ReferentialAction;
+(function (ReferentialAction) {
+    ReferentialAction["Cascade"] = "CASCADE";
+    ReferentialAction["Restrict"] = "RESTRICT";
+    ReferentialAction["SetNull"] = "SET NULL";
+    ReferentialAction["NoAction"] = "NO ACTION";
+    ReferentialAction["SetDefault"] = "SET DEFAULT";
+})(ReferentialAction || (exports.ReferentialAction = ReferentialAction = {}));
+// ==================== Logging Levels ====================
+/**
+ * Minimum log level for Prorm's built-in logger.
+ *
+ * This enum is a companion to the existing string-literal union used for
+ * `loggingLevel` (`'debug' | 'info' | 'warn' | 'error'`). Both forms are
+ * accepted wherever this field appears, so existing string literals
+ * continue to work unchanged.
+ *
+ * @example
+ * ```ts
+ * import { LoggingLevel } from 'prorm';
+ *
+ * new Prorm({
+ *   dialect: 'postgres',
+ *   loggingLevel: LoggingLevel.Warn,
+ * });
+ *
+ * // Equivalent to the string-literal form:
+ * new Prorm({
+ *   dialect: 'postgres',
+ *   loggingLevel: 'warn',
+ * });
+ * ```
+ */
+var LoggingLevel;
+(function (LoggingLevel) {
+    LoggingLevel["Debug"] = "debug";
+    LoggingLevel["Info"] = "info";
+    LoggingLevel["Warn"] = "warn";
+    LoggingLevel["Error"] = "error";
+})(LoggingLevel || (exports.LoggingLevel = LoggingLevel = {}));
+/**
+ * Sort direction for index column ordering.
+ *
+ * Companion enum for the `'ASC' | 'DESC'` string-literal union used by
+ * {@link IndexField.order}. Raw string literals remain valid; the enum is an
+ * additive, opt-in alternative.
+ *
+ * @example
+ * ```typescript
+ * // Using raw string literals (still supported)
+ * indexes: [{ fields: [{ name: 'email', order: 'DESC' }] }]
+ *
+ * // Using the SortDirection enum
+ * import { SortDirection } from 'prorm';
+ * indexes: [{ fields: [{ name: 'email', order: SortDirection.DESC }] }]
+ * ```
+ */
+var SortDirection;
+(function (SortDirection) {
+    SortDirection["ASC"] = "ASC";
+    SortDirection["DESC"] = "DESC";
+})(SortDirection || (exports.SortDirection = SortDirection = {}));
+/**
+ * Companion enum for `ValidateOnOption`. Mirrors the same fixed set of
+ * string values so callers who prefer enums (autocomplete, refactor-safe
+ * references, etc.) can use `ValidateOn.Create` instead of the raw string
+ * literal `'create'`. Both forms are accepted anywhere `ValidateOnOption`
+ * is used - this is purely additive and does not replace the string
+ * literal union.
+ */
+var ValidateOn;
+(function (ValidateOn) {
+    ValidateOn["Create"] = "create";
+    ValidateOn["Update"] = "update";
+    ValidateOn["Save"] = "save";
+    ValidateOn["SaveOnly"] = "saveOnly";
+})(ValidateOn || (exports.ValidateOn = ValidateOn = {}));
+/**
+ * Lock types for row-level locking
+ * - 'UPDATE': FOR UPDATE (PostgreSQL/MySQL) - prevents other transactions from modifying the rows
+ * - 'SHARE': FOR SHARE (PostgreSQL) / LOCK IN SHARE MODE (MySQL) - allows other transactions to read but not modify
+ * - 'KEY SHARE': FOR KEY SHARE (PostgreSQL only) - prevents key updates but allows row updates
+ */
+var LockLevel;
+(function (LockLevel) {
+    LockLevel["Share"] = "SHARE";
+    LockLevel["Update"] = "UPDATE";
+    LockLevel["KeyShare"] = "KEY SHARE";
+})(LockLevel || (exports.LockLevel = LockLevel = {}));
+// ==================== Transaction Options ====================
+/**
+ * Transaction class
+ */
+class Transaction {
+    constructor(options) {
+        this.id = `tx_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        this.finished = false;
+        this.options = options || {};
+        this.parent = null;
+        this.savepoints = [];
+    }
+    async commit() {
+        this.finished = true;
+    }
+    async rollback() {
+        this.finished = true;
+    }
+}
+exports.Transaction = Transaction;
+/**
+ * ANSI SQL transaction isolation levels.
+ *
+ * This is a companion enum for `IsolationLevelString` / the
+ * `TransactionOptions.isolationLevel` field. The field accepts both this
+ * enum and the raw string literals for backwards compatibility, so either
+ * of the following work:
+ * @example
+ * transaction.start({ isolationLevel: 'SERIALIZABLE' });
+ * @example
+ * transaction.start({ isolationLevel: IsolationLevel.Serializable });
+ */
+var IsolationLevel;
+(function (IsolationLevel) {
+    IsolationLevel["ReadUncommitted"] = "READ UNCOMMITTED";
+    IsolationLevel["ReadCommitted"] = "READ COMMITTED";
+    IsolationLevel["RepeatableRead"] = "REPEATABLE READ";
+    IsolationLevel["Serializable"] = "SERIALIZABLE";
+})(IsolationLevel || (exports.IsolationLevel = IsolationLevel = {}));
+// ==================== Query Types ====================
+/**
+ * Enum for query types used in prorm.query()
+ * @example
+ * prorm.query('SELECT * FROM users', { type: QueryTypes.SELECT })
+ * prorm.query('INSERT INTO users VALUES(...)', { type: QueryTypes.INSERT })
+ */
+var QueryTypes;
+(function (QueryTypes) {
+    QueryTypes["SELECT"] = "SELECT";
+    QueryTypes["INSERT"] = "INSERT";
+    QueryTypes["UPDATE"] = "UPDATE";
+    QueryTypes["DELETE"] = "DELETE";
+    QueryTypes["BULKINSERT"] = "BULKINSERT";
+    QueryTypes["BULKUPDATE"] = "BULKUPDATE";
+    QueryTypes["BULKDELETE"] = "BULKDELETE";
+    QueryTypes["RAW"] = "RAW";
+    QueryTypes["CALL"] = "CALL";
+})(QueryTypes || (exports.QueryTypes = QueryTypes = {}));

package/dist/user-management.js

@@ -0,0 +1,127 @@
+"use strict";
+/**
+ * User and privilege management for the TypeScript ORM.
+ * Supported dialects: MySQL, MariaDB (MySQL 8+ roles also supported).
+ * SQLite throws DatabaseError – user management is not a concept in SQLite.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserManager = exports.PRIVILEGE_LEVELS = void 0;
+/**
+ * Convenience groupings of privilege types by category.
+ */
+exports.PRIVILEGE_LEVELS = {
+    ALL: ['ALL PRIVILEGES'],
+    READ: ['SELECT'],
+    WRITE: ['INSERT', 'UPDATE', 'DELETE'],
+    DDL: ['CREATE', 'DROP', 'ALTER', 'INDEX'],
+    DML: ['SELECT', 'INSERT', 'UPDATE', 'DELETE'],
+    ROUTINE: ['EXECUTE', 'CREATE ROUTINE', 'ALTER ROUTINE'],
+    VIEW: ['CREATE VIEW', 'SHOW VIEW'],
+};
+class UserManager {
+    constructor(prorm) {
+        this.prorm = prorm;
+    }
+    // ---- User CRUD ----
+    async createUser(username, options) {
+        const dialect = this.prorm.dialect;
+        if (!dialect)
+            throw new Error('Database not connected');
+        const sql = dialect.buildCreateUserQuery(username, options);
+        await dialect.query(sql);
+    }
+    async alterUser(username, options) {
+        const dialect = this.prorm.dialect;
+        if (!dialect)
+            throw new Error('Database not connected');
+        const sql = dialect.buildAlterUserQuery(username, options);
+        await dialect.query(sql);
+    }
+    async dropUser(username, options) {
+        const dialect = this.prorm.dialect;
+        if (!dialect)
+            throw new Error('Database not connected');
+        const sql = dialect.buildDropUserQuery(username, options);
+        await dialect.query(sql);
+    }
+    async getUsers() {
+        const dialect = this.prorm.dialect;
+        if (!dialect)
+            throw new Error('Database not connected');
+        const sql = dialect.getUsersQuery();
+        const result = await dialect.query(sql);
+        return result.rows || [];
+    }
+    async userExists(username, host) {
+        const users = await this.getUsers();
+        return users.some((u) => u.user === username && (!host || u.host === host));
+    }
+    // ---- Grants ----
+    async grant(options) {
+        const dialect = this.prorm.dialect;
+        if (!dialect)
+            throw new Error('Database not connected');
+        const sql = dialect.buildGrantQuery(options);
+        await dialect.query(sql);
+    }
+    async revoke(options) {
+        const dialect = this.prorm.dialect;
+        if (!dialect)
+            throw new Error('Database not connected');
+        const sql = dialect.buildRevokeQuery(options);
+        await dialect.query(sql);
+    }
+    async showGrants(username, host) {
+        const dialect = this.prorm.dialect;
+        if (!dialect)
+            throw new Error('Database not connected');
+        const sql = dialect.buildShowGrantsQuery(username, host);
+        const result = await dialect.query(sql);
+        return result.rows || [];
+    }
+    async flushPrivileges() {
+        const dialect = this.prorm.dialect;
+        if (!dialect)
+            throw new Error('Database not connected');
+        const sql = dialect.buildFlushPrivilegesQuery();
+        await dialect.query(sql);
+    }
+    // ---- Roles (MySQL 8+ / MariaDB) ----
+    async createRole(roleName, options) {
+        const dialect = this.prorm.dialect;
+        if (!dialect)
+            throw new Error('Database not connected');
+        const sql = dialect.buildCreateRoleQuery(roleName, options);
+        await dialect.query(sql);
+    }
+    async dropRole(roleName, options) {
+        const dialect = this.prorm.dialect;
+        if (!dialect)
+            throw new Error('Database not connected');
+        const sql = dialect.buildDropRoleQuery(roleName, options);
+        await dialect.query(sql);
+    }
+    async grantRole(role, to, options) {
+        const dialect = this.prorm.dialect;
+        if (!dialect)
+            throw new Error('Database not connected');
+        const sql = dialect.buildGrantRoleQuery(role, to, options);
+        await dialect.query(sql);
+    }
+    async revokeRole(role, from, options) {
+        const dialect = this.prorm.dialect;
+        if (!dialect)
+            throw new Error('Database not connected');
+        const sql = dialect.buildRevokeRoleQuery(role, from, options);
+        await dialect.query(sql);
+    }
+    async getRoles() {
+        const dialect = this.prorm.dialect;
+        if (!dialect)
+            throw new Error('Database not connected');
+        const sql = dialect.getRolesQuery();
+        const result = await dialect.query(sql);
+        return (result.rows || []).map((r) => r.role || r.Role || r.rolname || '');
+    }
+}
+exports.UserManager = UserManager;

package/dist/utils/date.js

@@ -0,0 +1,300 @@
+"use strict";
+/**
+ * Date utility functions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dateUtils = exports.format = void 0;
+exports.now = now;
+exports.today = today;
+exports.tomorrow = tomorrow;
+exports.yesterday = yesterday;
+exports.addDays = addDays;
+exports.subtractDays = subtractDays;
+exports.addMonths = addMonths;
+exports.subtractMonths = subtractMonths;
+exports.addYears = addYears;
+exports.subtractYears = subtractYears;
+exports.formatDate = formatDate;
+exports.formatISO = formatISO;
+exports.formatRelative = formatRelative;
+exports.isToday = isToday;
+exports.isTomorrow = isTomorrow;
+exports.isYesterday = isYesterday;
+exports.isSameDay = isSameDay;
+exports.startOfDay = startOfDay;
+exports.endOfDay = endOfDay;
+exports.startOfMonth = startOfMonth;
+exports.endOfMonth = endOfMonth;
+exports.startOfYear = startOfYear;
+exports.endOfYear = endOfYear;
+exports.daysBetween = daysBetween;
+exports.isValidDate = isValidDate;
+// ==================== Date Utils ====================
+/**
+ * Get current date/time
+ */
+function now() {
+    return new Date();
+}
+/**
+ * Get today's date (midnight)
+ */
+function today() {
+    const d = new Date();
+    d.setHours(0, 0, 0, 0);
+    return d;
+}
+/**
+ * Get tomorrow's date (midnight)
+ */
+function tomorrow() {
+    const d = today();
+    d.setDate(d.getDate() + 1);
+    return d;
+}
+/**
+ * Get yesterday's date (midnight)
+ */
+function yesterday() {
+    const d = today();
+    d.setDate(d.getDate() - 1);
+    return d;
+}
+/**
+ * Add days to a date
+ */
+function addDays(date, days) {
+    const result = new Date(date);
+    result.setDate(result.getDate() + days);
+    return result;
+}
+/**
+ * Subtract days from a date
+ */
+function subtractDays(date, days) {
+    return addDays(date, -days);
+}
+/**
+ * Add months to a date
+ */
+function addMonths(date, months) {
+    const result = new Date(date);
+    result.setMonth(result.getMonth() + months);
+    return result;
+}
+/**
+ * Subtract months from a date
+ */
+function subtractMonths(date, months) {
+    return addMonths(date, -months);
+}
+/**
+ * Add years to a date
+ */
+function addYears(date, years) {
+    const result = new Date(date);
+    result.setFullYear(result.getFullYear() + years);
+    return result;
+}
+/**
+ * Subtract years from a date
+ */
+function subtractYears(date, years) {
+    return addYears(date, -years);
+}
+/**
+ * Format a date
+ * Format tokens: YYYY, YY, MM, DD, HH, mm, ss
+ *
+ * Note: exported as `formatDate` (not `format`) so it doesn't collide with
+ * the numeric `format(value, decimals)` helper in './index'. Local exports
+ * in index.ts take precedence over this module's `export * from './date'`
+ * re-export for identically-named bindings, so a top-level `utils.format`
+ * pointing at a date formatter would silently break numeric-formatting
+ * callers (and vice versa).
+ */
+function formatDate(date, formatStr = 'YYYY-MM-DD') {
+    // Use UTC getters so formatting is stable regardless of the host's local
+    // timezone. `new Date('2024-01-15')` (a date-only ISO string) parses as
+    // UTC midnight; using local getters (getDate/getMonth/...) shifts the
+    // result by a day in timezones behind UTC.
+    const year = date.getUTCFullYear();
+    const month = String(date.getUTCMonth() + 1).padStart(2, '0');
+    const day = String(date.getUTCDate()).padStart(2, '0');
+    const hours = String(date.getUTCHours()).padStart(2, '0');
+    const minutes = String(date.getUTCMinutes()).padStart(2, '0');
+    const seconds = String(date.getUTCSeconds()).padStart(2, '0');
+    return formatStr
+        .replace('YYYY', String(year))
+        .replace('YY', String(year).slice(-2))
+        .replace('MM', month)
+        .replace('DD', day)
+        .replace('HH', hours)
+        .replace('mm', minutes)
+        .replace('ss', seconds);
+}
+/**
+ * Format a date (alias for formatDate). Kept for direct
+ * `import { format } from './utils/date'` consumers; not re-exported at the
+ * top-level `utils` barrel under this name (see note above).
+ */
+exports.format = formatDate;
+/**
+ * Format date as ISO string (YYYY-MM-DD)
+ */
+function formatISO(date) {
+    return date.toISOString().split('T')[0];
+}
+/**
+ * Get relative time string (e.g., "2 hours ago", "in 3 days")
+ */
+function formatRelative(date) {
+    const now = new Date();
+    const diffMs = date.getTime() - now.getTime();
+    const diffSeconds = Math.round(diffMs / 1000);
+    const diffMinutes = Math.round(diffSeconds / 60);
+    const diffHours = Math.round(diffMinutes / 60);
+    const diffDays = Math.round(diffHours / 24);
+    if (diffSeconds < 0) {
+        // Past
+        if (Math.abs(diffSeconds) < 60)
+            return 'just now';
+        if (Math.abs(diffMinutes) < 60)
+            return `${Math.abs(diffMinutes)} minute${Math.abs(diffMinutes) === 1 ? '' : 's'} ago`;
+        if (Math.abs(diffHours) < 24)
+            return `${Math.abs(diffHours)} hour${Math.abs(diffHours) === 1 ? '' : 's'} ago`;
+        if (Math.abs(diffDays) < 30)
+            return `${Math.abs(diffDays)} day${Math.abs(diffDays) === 1 ? '' : 's'} ago`;
+        return (0, exports.format)(date);
+    }
+    else {
+        // Future
+        if (diffSeconds < 60)
+            return 'just now';
+        if (diffMinutes < 60)
+            return `in ${diffMinutes} minute${diffMinutes === 1 ? '' : 's'}`;
+        if (diffHours < 24)
+            return `in ${diffHours} hour${diffHours === 1 ? '' : 's'}`;
+        if (diffDays < 30)
+            return `in ${diffDays} day${diffDays === 1 ? '' : 's'}`;
+        return (0, exports.format)(date);
+    }
+}
+/**
+ * Check if date is today
+ */
+function isToday(date) {
+    return isSameDay(date, new Date());
+}
+/**
+ * Check if date is tomorrow
+ */
+function isTomorrow(date) {
+    return isSameDay(date, tomorrow());
+}
+/**
+ * Check if date is yesterday
+ */
+function isYesterday(date) {
+    return isSameDay(date, yesterday());
+}
+/**
+ * Check if two dates are the same day
+ */
+function isSameDay(date1, date2) {
+    return (date1.getFullYear() === date2.getFullYear() &&
+        date1.getMonth() === date2.getMonth() &&
+        date1.getDate() === date2.getDate());
+}
+/**
+ * Get start of day (midnight)
+ */
+function startOfDay(date) {
+    const result = new Date(date);
+    result.setHours(0, 0, 0, 0);
+    return result;
+}
+/**
+ * Get end of day (23:59:59.999)
+ */
+function endOfDay(date) {
+    const result = new Date(date);
+    result.setHours(23, 59, 59, 999);
+    return result;
+}
+/**
+ * Get start of month
+ */
+function startOfMonth(date) {
+    const result = new Date(date);
+    result.setDate(1);
+    return startOfDay(result);
+}
+/**
+ * Get end of month
+ */
+function endOfMonth(date) {
+    const result = new Date(date.getFullYear(), date.getMonth() + 1, 0);
+    return endOfDay(result);
+}
+/**
+ * Get start of year
+ */
+function startOfYear(date) {
+    const result = new Date(date);
+    result.setMonth(0, 1);
+    return startOfDay(result);
+}
+/**
+ * Get end of year
+ */
+function endOfYear(date) {
+    const result = new Date(date.getFullYear(), 11, 31);
+    return endOfDay(result);
+}
+/**
+ * Get number of days between two dates
+ */
+function daysBetween(date1, date2) {
+    const oneDay = 24 * 60 * 60 * 1000;
+    const firstDay = new Date(date1.getFullYear(), date1.getMonth(), date1.getDate());
+    const secondDay = new Date(date2.getFullYear(), date2.getMonth(), date2.getDate());
+    return Math.round((secondDay.getTime() - firstDay.getTime()) / oneDay);
+}
+/**
+ * Check if value is a valid date
+ */
+function isValidDate(date) {
+    return date instanceof Date && !isNaN(date.getTime());
+}
+/**
+ * Date utilities object for convenient access
+ */
+exports.dateUtils = {
+    now,
+    today,
+    tomorrow,
+    yesterday,
+    addDays,
+    subtractDays,
+    addMonths,
+    subtractMonths,
+    addYears,
+    subtractYears,
+    format: exports.format,
+    formatISO,
+    formatRelative,
+    isToday,
+    isTomorrow,
+    isYesterday,
+    isSameDay,
+    startOfDay,
+    endOfDay,
+    startOfMonth,
+    endOfMonth,
+    startOfYear,
+    endOfYear,
+    daysBetween,
+    isValidDate,
+};
+exports.default = exports.dateUtils;