velocious 1.0.455 → 1.0.457

package/README.md

@@ -5,7 +5,7 @@
 * Database models with migrations and validations
 * Database models that work almost the same in frontend and backend
 * Declarative state machines for models (see [docs/state-machine.md](docs/state-machine.md))
-* Migrations for schema changes (see [docs/database-migrations.md](docs/database-migrations.md))
+* Migrations for schema changes and UTC datetime storage (see [docs/database-migrations.md](docs/database-migrations.md))
 * Controllers and views for HTTP endpoints
 * Frontend-model transport for creating, updating, querying, and subscribing to query-filtered lifecycle events over HTTP/WebSocket, with structured per-attribute validation error responses (see [docs/frontend-models.md](docs/frontend-models.md))
 * Expo / Metro compatibility guidance and a real Expo export check (see [docs/expo-metro-compatibility.md](docs/expo-metro-compatibility.md))

package/build/cli/commands/db/drop.js

@@ -32,9 +32,13 @@ export default class DbDrop extends DbBaseCommand {
         const configuredFallback = newConfiguration.useDatabase
         const useConfiguredFallback = typeof configuredFallback == "string" && configuredFallback.length > 0 && configuredFallback != targetDatabaseName
 
-        newConfiguration.database = useConfiguredFallback
-          ? configuredFallback
-          : this.systemFallbackDatabaseName(databaseType)
+        if (useConfiguredFallback) {
+          newConfiguration.database = configuredFallback
+        } else if (databaseType == "mysql") {
+          delete newConfiguration.database
+        } else {
+          newConfiguration.database = this.systemFallbackDatabaseName(databaseType)
+        }
 
         if (databaseType == "mssql" && newConfiguration.sqlConfig?.database) {
           delete newConfiguration.sqlConfig.database

package/build/database/datetime-storage.js

@@ -0,0 +1,188 @@
+// @ts-check
+
+import isDate from "../utils/is-date.js"
+
+const dateTimeWithTimezonePattern = /^\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?(?:[zZ]|[+-]\d{2}:\d{2})$/
+const dateTimeWithoutTimezonePattern = /^\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?$/
+const timezoneSuffixPattern = /(?:[zZ]|[+-]\d{2}:\d{2})$/
+
+/**
+ * Pads a numeric date/time part.
+ * @param {number} value - Numeric part.
+ * @param {number} length - Target length.
+ * @returns {string} - Padded part.
+ */
+function pad(value, length = 2) {
+  return String(value).padStart(length, "0")
+}
+
+/**
+ * Replaces SQL-style datetime separators with ISO separators for parsing.
+ * @param {string} value - Datetime string.
+ * @returns {string} - Datetime string with a `T` separator.
+ */
+function normalizeDateTimeSeparator(value) {
+  return value.includes("T") ? value : value.replace(" ", "T")
+}
+
+/**
+ * Parses a datetime string with an explicit timezone.
+ * @param {string} value - Datetime string.
+ * @returns {Date | string} - Parsed date or the original string when it is not a recognized datetime.
+ */
+function parseTimezoneQualifiedDateTimeString(value) {
+  if (!dateTimeWithTimezonePattern.test(value)) return value
+
+  const timestamp = Date.parse(normalizeDateTimeSeparator(value))
+
+  if (Number.isNaN(timestamp)) return value
+
+  return new Date(timestamp)
+}
+
+/**
+ * Parses a timezone-less datetime string as UTC.
+ * @param {string} value - Datetime string.
+ * @returns {Date | string} - Parsed date or the original string when it is not a recognized datetime.
+ */
+function parseTimezoneLessDateTimeStringAsUtc(value) {
+  if (!dateTimeWithoutTimezonePattern.test(value)) return value
+
+  const timestamp = Date.parse(`${normalizeDateTimeSeparator(value)}Z`)
+
+  if (Number.isNaN(timestamp)) return value
+
+  return new Date(timestamp)
+}
+
+/**
+ * Parses a timezone-less datetime string as the current runtime's local wall-clock time.
+ * @param {string} value - Datetime string.
+ * @returns {Date | string} - Parsed date or the original string when it is not a recognized datetime.
+ */
+function parseTimezoneLessDateTimeStringAsLocal(value) {
+  if (!dateTimeWithoutTimezonePattern.test(value)) return value
+
+  const timestamp = Date.parse(normalizeDateTimeSeparator(value))
+
+  if (Number.isNaN(timestamp)) return value
+
+  return new Date(timestamp)
+}
+
+/**
+ * Parses a timezone-less legacy datetime string with an explicit local offset.
+ * The offset follows JavaScript's `Date#getTimezoneOffset()` sign convention.
+ * @param {string} value - Datetime string.
+ * @param {number} legacyLocalOffsetMinutes - UTC-minus-local offset in minutes.
+ * @returns {Date | string} - Parsed date or the original string when it is not a recognized datetime.
+ */
+function parseTimezoneLessDateTimeStringWithOffset(value, legacyLocalOffsetMinutes) {
+  const utcDate = parseTimezoneLessDateTimeStringAsUtc(value)
+
+  if (!isDate(utcDate)) return value
+
+  return new Date(utcDate.getTime() + (legacyLocalOffsetMinutes * 60 * 1000))
+}
+
+/**
+ * Checks whether a string has a datetime timezone suffix.
+ * @param {string} value - Value to check.
+ * @returns {boolean} - Whether the string ends with `Z` or an offset.
+ */
+export function hasDateTimeTimezone(value) {
+  return timezoneSuffixPattern.test(value)
+}
+
+/**
+ * Formats a Date for database storage as a UTC instant.
+ * @param {Date} value - Date value.
+ * @param {object} args - Options.
+ * @param {string} args.databaseType - Database driver type.
+ * @returns {string} - Database datetime string.
+ */
+export function formatDateForDatabase(value, {databaseType}) {
+  if (databaseType == "sqlite") return value.toISOString()
+
+  return [
+    value.getUTCFullYear(),
+    "-",
+    pad(value.getUTCMonth() + 1),
+    "-",
+    pad(value.getUTCDate()),
+    " ",
+    pad(value.getUTCHours()),
+    ":",
+    pad(value.getUTCMinutes()),
+    ":",
+    pad(value.getUTCSeconds()),
+    ".",
+    pad(value.getUTCMilliseconds(), 3)
+  ].join("")
+}
+
+/**
+ * Normalizes a record write string into a Date when it is a recognized datetime string.
+ * Timezone-less strings are external input and are treated as UTC.
+ * @param {string} value - Value to normalize.
+ * @returns {Date | string} - Normalized value.
+ */
+export function normalizeDateStringForWrite(value) {
+  if (hasDateTimeTimezone(value)) return parseTimezoneQualifiedDateTimeString(value)
+
+  return parseTimezoneLessDateTimeStringAsUtc(value)
+}
+
+/**
+ * Normalizes a record write value into a Date when it is a recognized datetime string.
+ * Timezone-less strings are external input and are treated as UTC.
+ * @param {Date | string | null | undefined} value - Value to normalize.
+ * @returns {Date | string | null | undefined} - Normalized value.
+ */
+export function normalizeDateValueForWrite(value) {
+  if (typeof value != "string") return value
+
+  return normalizeDateStringForWrite(value)
+}
+
+/**
+ * Normalizes a database value into a Date for record reads.
+ * SQLite timezone-less rows are legacy local wall-clock rows produced before
+ * UTC storage. New SQLite writes include `Z`, so they take the exact branch.
+ * @param {Date | string | null | undefined} value - Stored database value.
+ * @param {object} args - Options.
+ * @param {string} args.databaseType - Database driver type.
+ * @returns {Date | string | null | undefined} - Normalized value.
+ */
+export function normalizeDateValueForRead(value, {databaseType}) {
+  if (value === null || value === undefined) return value
+
+  if (isDate(value)) return new Date(value.getTime())
+  if (typeof value != "string") return value
+  if (hasDateTimeTimezone(value)) return parseTimezoneQualifiedDateTimeString(value)
+  if (databaseType == "sqlite") return parseTimezoneLessDateTimeStringAsLocal(value)
+
+  return parseTimezoneLessDateTimeStringAsUtc(value)
+}
+
+/**
+ * Converts a legacy timezone-less datetime value into the new UTC database storage format.
+ * The optional offset follows JavaScript's `Date#getTimezoneOffset()` sign convention.
+ * @param {Date | string | null | undefined} value - Legacy value.
+ * @param {object} args - Options.
+ * @param {string} args.databaseType - Database driver type.
+ * @param {number | undefined} [args.legacyLocalOffsetMinutes] - UTC-minus-local offset in minutes.
+ * @returns {Date | string | null | undefined} - Converted database value or the original value.
+ */
+export function convertLegacyDateValueToUtcStorage(value, {databaseType, legacyLocalOffsetMinutes}) {
+  if (typeof value != "string") return value
+  if (hasDateTimeTimezone(value)) return value
+
+  const parsedDate = legacyLocalOffsetMinutes === undefined
+    ? parseTimezoneLessDateTimeStringAsLocal(value)
+    : parseTimezoneLessDateTimeStringWithOffset(value, legacyLocalOffsetMinutes)
+
+  if (!isDate(parsedDate)) return value
+
+  return formatDateForDatabase(parsedDate, {databaseType})
+}

package/build/database/drivers/base.js

@@ -103,12 +103,12 @@
 
 import BacktraceCleaner from "../../utils/backtrace-cleaner.js"
 import { getDatabaseAnnotations } from "../annotations.js"
+import { formatDateForDatabase } from "../datetime-storage.js"
 import isDate from "../../utils/is-date.js"
 import Logger from "../../logger.js"
 import Query from "../query/index.js"
 import Handler from "../handler.js"
 import Mutex from "epic-locks/build/mutex.js"
-import strftime from "strftime"
 import UUID from "pure-uuid"
 import TableData from "../table-data/index.js"
 import TableColumn from "../table-data/table-column.js"
@@ -656,7 +656,7 @@ export default class VelociousDatabaseDriversBase {
     // isDate instead of instanceof: a Date created in another realm (e.g. the console REPL) would
     // fail instanceof, skip this conversion, and serialize as an empty SQL value downstream.
     if (isDate(value)) {
-      return strftime("%F %T.%L", value)
+      return formatDateForDatabase(value, {databaseType: this.getType()})
     }
 
     // JSON-encode plain objects/arrays so they land in JSON/text columns as valid

package/build/database/drivers/mssql/index.js

@@ -30,6 +30,10 @@ export default class VelociousDatabaseDriversMssql extends Base{
     try {
       if (this.connection) await this.close()
 
+      if (sqlConfig) {
+        sqlConfig.options = Object.assign({}, sqlConfig.options, {useUTC: true})
+      }
+
       if (sqlConfig?.server && !sqlConfig.options?.serverName && net.isIP(sqlConfig.server)) {
         sqlConfig.options = Object.assign({}, sqlConfig.options, {serverName: ""})
       }

package/build/database/drivers/mysql/index.js

@@ -37,6 +37,8 @@ export default class VelociousDatabaseDriversMysql extends Base{
   async connect() {
     this.pool = mysql.createPool(Object.assign({connectionLimit: 1}, this.connectArgs()))
     this.pool.on("error", this.onPoolError)
+
+    await this.setSessionTimezoneToUtc()
   }
 
   /**
@@ -75,6 +77,14 @@ export default class VelociousDatabaseDriversMysql extends Base{
     await super.clearConnectionCheckoutName()
   }
 
+  /**
+   * Sets the database session timezone to UTC so bare timestamp literals store UTC instants.
+   * @returns {Promise<void>} - Resolves when complete.
+   */
+  async setSessionTimezoneToUtc() {
+    await this.query("SET time_zone = '+00:00'", {logName: "Set Session Time Zone", processListComment: false})
+  }
+
   /**
    * Runs connect args.
    * @returns {Record<string, ?>} - The connect args.
@@ -86,7 +96,7 @@ export default class VelociousDatabaseDriversMysql extends Base{
     /**
      * Connect args.
      * @type {Record<string, ?>} */
-    const connectArgs = {charset: "utf8mb4"}
+    const connectArgs = {charset: "utf8mb4", timezone: "Z"}
 
     for (const forwardValue of forward) {
       if (forwardValue in args) connectArgs[forwardValue] = digg(args, forwardValue)

package/build/database/drivers/pgsql/index.js

@@ -3,7 +3,7 @@
 import AlterTable from "./sql/alter-table.js"
 import wait from "awaitery/build/wait.js"
 import Base from "../base.js"
-import {Client} from "pg"
+import { Client, types as pgTypes } from "pg"
 import CreateDatabase from "./sql/create-database.js"
 import CreateIndex from "./sql/create-index.js"
 import CreateTable from "./sql/create-table.js"
@@ -19,12 +19,18 @@ import StructureSql from "./structure-sql.js"
 import Upsert from "./sql/upsert.js"
 import Update from "./sql/update.js"
 
+const PG_TIMESTAMP_WITHOUT_TIMEZONE_OID = 1114
+
+pgTypes.setTypeParser(PG_TIMESTAMP_WITHOUT_TIMEZONE_OID, (value) => new Date(`${value.replace(" ", "T")}Z`))
+
 export default class VelociousDatabaseDriversPgsql extends Base{
   async connect() {
     const client = new Client(this.connectArgs())
 
     try {
       await client.connect()
+      this.connection = client
+      await this.setSessionTimezoneToUtc()
     } catch (error) {
       // Re-throw to recover real stack trace
       if (error instanceof Error) {
@@ -33,8 +39,6 @@ export default class VelociousDatabaseDriversPgsql extends Base{
         throw new Error(`Connect to Postgres server failed: ${error}`, {cause: error})
       }
     }
-
-    this.connection = client
   }
 
   connectArgs() {
@@ -85,6 +89,14 @@ export default class VelociousDatabaseDriversPgsql extends Base{
     await super.clearConnectionCheckoutName()
   }
 
+  /**
+   * Sets the database session timezone to UTC so bare timestamp literals store UTC instants.
+   * @returns {Promise<void>} - Resolves when complete.
+   */
+  async setSessionTimezoneToUtc() {
+    await this.query("SET TIME ZONE 'UTC'", {logName: "Set Session Time Zone", processListComment: false})
+  }
+
   /**
    * Runs alter table sqls.
    * @param {import("../../table-data/index.js").default} tableData - Table data.

package/build/database/migration/index.js

@@ -26,7 +26,15 @@
  * CreateTableCallbackType type.
  * @typedef {(table: TableData) => void} CreateTableCallbackType
  */
+/**
+ * LegacyLocalDateTimesMigrationArgsType type.
+ * @typedef {object} LegacyLocalDateTimesMigrationArgsType
+ * @property {Record<string, string[]>} [columnsByTable] - Explicit datetime columns keyed by table name.
+ * @property {number} [legacyLocalOffsetMinutes] - UTC-minus-local offset in minutes for legacy rows.
+ * @property {string[]} [tables] - Tables to migrate. Defaults to all non-internal tables.
+ */
 
+import { convertLegacyDateValueToUtcStorage } from "../datetime-storage.js"
 import * as inflection from "inflection"
 import restArgsError from "../../utils/rest-args-error.js"
 import TableData from "../table-data/index.js"
@@ -275,6 +283,125 @@ export default class VelociousDatabaseMigration {
     await column.changeNullable(nullable)
   }
 
+  /**
+   * Migrates legacy timezone-less local datetime rows into UTC datetime storage.
+   * New SQLite UTC rows include a timezone suffix and are skipped.
+   * @param {LegacyLocalDateTimesMigrationArgsType} [args] - Migration options.
+   * @returns {Promise<void>} - Resolves when complete.
+   */
+  async migrateLegacyLocalDateTimesToUtcStorage(args = {}) {
+    const {columnsByTable, legacyLocalOffsetMinutes, tables, ...restArgs} = args
+
+    restArgsError(restArgs)
+
+    const tableNames = await this._legacyLocalDateTimesTableNames(tables)
+
+    for (const tableName of tableNames) {
+      await this._migrateLegacyLocalDateTimesTable({
+        columnsByTable,
+        legacyLocalOffsetMinutes,
+        tableName
+      })
+    }
+  }
+
+  /**
+   * Resolves table names for a legacy local datetime migration.
+   * @param {string[] | undefined} tables - Explicit table names.
+   * @returns {Promise<string[]>} - Table names.
+   */
+  async _legacyLocalDateTimesTableNames(tables) {
+    if (tables) return tables
+
+    return (await this.getDriver().getTables())
+      .map((table) => table.getName())
+      .filter((tableName) => tableName != "schema_migrations" && !tableName.startsWith("sqlite_"))
+  }
+
+  /**
+   * Migrates one table's legacy local datetime values.
+   * @param {object} args - Options.
+   * @param {Record<string, string[]> | undefined} args.columnsByTable - Explicit columns keyed by table.
+   * @param {number | undefined} args.legacyLocalOffsetMinutes - UTC-minus-local offset in minutes.
+   * @param {string} args.tableName - Table name.
+   * @returns {Promise<void>} - Resolves when complete.
+   */
+  async _migrateLegacyLocalDateTimesTable({columnsByTable, legacyLocalOffsetMinutes, tableName}) {
+    const driver = this.getDriver()
+    const table = await driver.getTableByNameOrFail(tableName)
+    const columns = await this._legacyLocalDateTimesColumns({columnsByTable, table})
+
+    if (columns.length === 0) return
+
+    const primaryKeyColumn = await this._legacyLocalDateTimesPrimaryKey(table)
+    const selectedColumns = [primaryKeyColumn, ...columns]
+    const selectSql = selectedColumns
+      .map((columnName) => driver.quoteColumn(columnName))
+      .join(", ")
+    const rows = await driver.query(`SELECT ${selectSql} FROM ${driver.quoteTable(tableName)}`)
+
+    for (const row of rows) {
+      for (const columnName of columns) {
+        const value = row[columnName]
+        const convertedValue = convertLegacyDateValueToUtcStorage(value, {
+          databaseType: driver.getType(),
+          legacyLocalOffsetMinutes
+        })
+
+        if (convertedValue === value) continue
+
+        await driver.query(`
+          UPDATE ${driver.quoteTable(tableName)}
+          SET ${driver.quoteColumn(columnName)} = ${driver.quote(convertedValue)}
+          WHERE ${driver.quoteColumn(primaryKeyColumn)} = ${driver.quote(row[primaryKeyColumn])}
+        `)
+      }
+    }
+  }
+
+  /**
+   * Resolves date-like columns for one table.
+   * @param {object} args - Options.
+   * @param {Record<string, string[]> | undefined} args.columnsByTable - Explicit columns keyed by table.
+   * @param {import("../drivers/base-table.js").default} args.table - Table metadata.
+   * @returns {Promise<string[]>} - Date-like column names.
+   */
+  async _legacyLocalDateTimesColumns({columnsByTable, table}) {
+    const explicitColumns = columnsByTable?.[table.getName()]
+
+    if (explicitColumns) return explicitColumns
+
+    return (await table.getColumns())
+      .filter((column) => this._legacyLocalDateTimesColumnIsDateLike(column))
+      .map((column) => column.getName())
+  }
+
+  /**
+   * Checks whether a column should be included by default.
+   * @param {import("../drivers/base-column.js").default} column - Column metadata.
+   * @returns {boolean} - Whether the column is date-like.
+   */
+  _legacyLocalDateTimesColumnIsDateLike(column) {
+    const columnType = column.getType().toLowerCase()
+
+    return columnType.includes("date") || columnType.includes("timestamp")
+  }
+
+  /**
+   * Resolves the single primary key column for row updates.
+   * @param {import("../drivers/base-table.js").default} table - Table metadata.
+   * @returns {Promise<string>} - Primary key column name.
+   */
+  async _legacyLocalDateTimesPrimaryKey(table) {
+    const primaryKeyColumns = (await table.getColumns()).filter((column) => column.getPrimaryKey())
+
+    if (primaryKeyColumns.length != 1) {
+      throw new Error(`Expected exactly one primary key on ${table.getName()} but found ${primaryKeyColumns.length}`)
+    }
+
+    return primaryKeyColumns[0].getName()
+  }
+
   /**
    * Runs column exists.
    * @param {string} tableName - Table name.

package/build/database/record/index.js

@@ -31,13 +31,13 @@ import HasOneRelationship from "./relationships/has-one.js"
 import RecordAttachmentHandle from "./attachments/handle.js"
 import * as inflection from "inflection"
 import deburrColumnName from "../../utils/deburr-column-name.js"
-import isDate from "../../utils/is-date.js"
 import ModelClassQuery from "../query/model-class-query.js"
 import Preloader from "../query/preloader.js"
 import {readPayloadAssociationCount, readPayloadComputedAbility, readPayloadQueryData, setPayloadAssociationCount, setPayloadComputedAbility, setPayloadQueryData} from "../../record-payload-values.js"
 import restArgsError from "../../utils/rest-args-error.js"
 import singularizeModelName from "../../utils/singularize-model-name.js"
 import {defineModelScope} from "../../utils/model-scope.js"
+import { normalizeDateStringForWrite, normalizeDateValueForRead, normalizeDateValueForWrite } from "../datetime-storage.js"
 import {formatValue} from "../../utils/format-value.js"
 import ValidatorsFormat from "./validators/format.js"
 import ValidatorsPresence from "./validators/presence.js"
@@ -1866,17 +1866,7 @@ class VelociousDatabaseRecord {
    * @returns {?} - The date value.
    */
   _normalizeDateValue(value) {
-    if (typeof value != "string") return value
-
-    const isoDateTimeRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?(?:Z|[+-]\d{2}:\d{2})$/
-
-    if (!isoDateTimeRegex.test(value)) return value
-
-    const timestamp = Date.parse(value)
-
-    if (Number.isNaN(timestamp)) return value
-
-    return new Date(timestamp)
+    return normalizeDateValueForWrite(value)
   }
 
   /**
@@ -2240,21 +2230,7 @@ class VelociousDatabaseRecord {
    * @returns {?} - Normalized value.
    */
   static _normalizeDateValueForInsert(value) {
-    let normalizedValue = value
-
-    if (typeof normalizedValue == "string") {
-      normalizedValue = this._normalizeDateStringForInsert(normalizedValue)
-    }
-
-    if (isDate(normalizedValue)) {
-      const configuration = this._getConfiguration()
-      const offsetMinutes = configuration.getEnvironmentHandler().getTimezoneOffsetMinutes(configuration)
-      const offsetMs = offsetMinutes * 60 * 1000
-
-      normalizedValue = new Date(normalizedValue.getTime() - offsetMs)
-    }
-
-    return normalizedValue
+    return normalizeDateValueForWrite(value)
   }
 
   /**
@@ -2263,15 +2239,7 @@ class VelociousDatabaseRecord {
    * @returns {string | Date} - Parsed date or original string.
    */
   static _normalizeDateStringForInsert(value) {
-    const isoDateTimeRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?(?:Z|[+-]\d{2}:\d{2})$/
-
-    if (!isoDateTimeRegex.test(value)) return value
-
-    const timestamp = Date.parse(value)
-
-    if (Number.isNaN(timestamp)) return value
-
-    return new Date(timestamp)
+    return normalizeDateStringForWrite(value)
   }
 
   /**
@@ -3925,26 +3893,7 @@ class VelociousDatabaseRecord {
    * @returns {?} - Normalized value.
    */
   _normalizeDateValueForRead(value) {
-    if (value === null || value === undefined) return value
-
-    const configuration = this.getModelClass()._getConfiguration()
-    const offsetMinutes = configuration.getEnvironmentHandler().getTimezoneOffsetMinutes(configuration)
-    const offsetMs = offsetMinutes * 60 * 1000
-
-    if (isDate(value)) {
-      return new Date(value.getTime() + offsetMs)
-    }
-
-    if (typeof value != "string") return value
-
-    const hasTimezone = /[zZ]|[+-]\d{2}:\d{2}$/.test(value)
-    const normalized = value.includes("T") ? value : value.replace(" ", "T")
-    const parseValue = hasTimezone ? normalized : `${normalized}Z`
-    const parsed = Date.parse(parseValue)
-
-    if (Number.isNaN(parsed)) return value
-
-    return new Date(parsed + offsetMs)
+    return normalizeDateValueForRead(value, {databaseType: this.getModelClass().getDatabaseType()})
   }
 
   _belongsToChanges() {
@@ -4079,10 +4028,6 @@ class VelociousDatabaseRecord {
    * @returns {void} - No return value.
    */
   _normalizeDateValuesForWrite(data) {
-    const configuration = this.getModelClass()._getConfiguration()
-    const offsetMinutes = configuration.getEnvironmentHandler().getTimezoneOffsetMinutes(configuration)
-    const offsetMs = offsetMinutes * 60 * 1000
-
     for (const columnName in data) {
       const columnType = this.getModelClass().getColumnTypeByName(columnName)
 
@@ -4090,9 +4035,7 @@ class VelociousDatabaseRecord {
 
       const value = data[columnName]
 
-      if (!isDate(value)) continue
-
-      data[columnName] = new Date(value.getTime() - offsetMs)
+      data[columnName] = normalizeDateValueForWrite(value)
     }
   }
 

package/build/environment-handlers/node/cli/commands/generate/frontend-models.js

@@ -106,7 +106,13 @@ export default class DbGenerateFrontendModels extends BaseCommand {
           throw new Error(`Invalid frontend model resource definition for '${className}'`)
         }
 
-        const resourceClass = frontendModelResourceClassFromDefinition(resources[modelClassName])
+        const resolvedResourceClass = frontendModelResourceClassFromDefinition(resources[modelClassName])
+        // An abstract base resource (no static ModelClass — e.g. an app's shared
+        // `BaseResource` that other resources extend) can't back a generated
+        // frontend model. Treat it as resource-less so the generator falls back
+        // to by-name model lookup + empty write params instead of throwing when
+        // it eagerly calls `modelClass()` / `permittedParams()` on it.
+        const resourceClass = resolvedResourceClass && resolvedResourceClass.ModelClass ? resolvedResourceClass : null
 
         this.validateModelConfig({availableFrontendModelClassNames, className, modelConfig, resourceClass})
 
@@ -1516,7 +1522,12 @@ export default class DbGenerateFrontendModels extends BaseCommand {
       const classBodyEnd = this.matchingBraceIndex({openIndex: classBodyStart - 1, sourceText})
 
       if (classBodyEnd == null) {
-        throw new Error(`Could not find closing brace for resource class '${className}' while reading frontend attribute JSDoc`)
+        // The brace matcher can't tokenize every construct (e.g. a regex literal
+        // whose quotes look like string delimiters), so it can fail to locate a
+        // class body. Skip metadata extraction for that class rather than
+        // aborting the whole frontend-model generation; resources that parse
+        // cleanly still get their JSDoc-derived return/param types.
+        continue
       }
 
       const classBody = sourceText.slice(classBodyStart, classBodyEnd)
@@ -1557,7 +1568,12 @@ export default class DbGenerateFrontendModels extends BaseCommand {
       const classBodyEnd = this.matchingBraceIndex({openIndex: classBodyStart - 1, sourceText})
 
       if (classBodyEnd == null) {
-        throw new Error(`Could not find closing brace for resource class '${className}' while reading frontend attribute JSDoc`)
+        // The brace matcher can't tokenize every construct (e.g. a regex literal
+        // whose quotes look like string delimiters), so it can fail to locate a
+        // class body. Skip metadata extraction for that class rather than
+        // aborting the whole frontend-model generation; resources that parse
+        // cleanly still get their JSDoc-derived return/param types.
+        continue
       }
 
       const classBody = sourceText.slice(classBodyStart, classBodyEnd)

package/build/frontend-model-controller.js

@@ -10,7 +10,9 @@ import {normalizeGroup as normalizeQueryGroup, normalizeJoins as normalizeQueryJ
 import {assignSafeProperty, deserializeFrontendModelTransportValue, isBackendModelInstance, serializeFrontendModelTransportValue} from "./frontend-models/transport-serialization.js"
 import RoutesResolver from "./routes/resolver.js"
 import {ValidationError} from "./database/record/index.js"
+import { normalizeDateStringForWrite } from "./database/datetime-storage.js"
 import VelociousError from "./velocious-error.js"
+import isDate from "./utils/is-date.js"
 import isPlainObject from "./utils/plain-object.js"
 
 /**
@@ -2212,9 +2214,9 @@ export default class FrontendModelController extends Controller {
       const isDateTimeColumn = typeof columnType === "string" && ["date", "datetime", "timestamp"].some((type) => columnType.includes(type))
 
       if (isDateTimeColumn) {
-        const parsedDate = new Date(value)
+        const parsedDate = normalizeDateStringForWrite(value)
 
-        if (!Number.isNaN(parsedDate.getTime())) {
+        if (isDate(parsedDate)) {
           return parsedDate
         }
       }