velocious 1.0.674 → 1.0.676

package/src/database/query/order-base.js

@@ -27,6 +27,15 @@ export default class VelociousDatabaseQueryOrderBase {
     throw new Error("setReverseOrder not implemented")
   }
 
+  /**
+   * Runs reversed copy.
+   * @abstract
+   * @returns {import("./order-base.js").default} - A new independent order with the direction reversed.
+   */
+  reversedCopy() {
+    throw new Error("reversedCopy not implemented")
+  }
+
   toSql() {
     throw new Error("'toSql' wasn't implemented")
   }

package/src/database/query/order-column.js

@@ -59,6 +59,16 @@ export default class VelociousDatabaseQueryOrderColumn extends OrderBase {
     this.reverseOrder = reverseOrder
   }
 
+  /**
+   * Runs reversed copy.
+   * @returns {VelociousDatabaseQueryOrderColumn} - A new independent order reversing the effective (rendered) direction.
+   */
+  reversedCopy() {
+    const direction = this.reverseOrder ? this.direction : reverseDirection(this.direction)
+
+    return new VelociousDatabaseQueryOrderColumn(this.query, {column: this.column, direction, tableName: this.tableName})
+  }
+
   /**
    * Runs to sql.
    * @returns {string} - SQL string.

package/src/database/query/order-plain.js

@@ -18,6 +18,22 @@ export default class VelociousDatabaseQueryOrderPlain extends OrderBase {
     this.reverseOrder = true
   }
 
+  /**
+   * Runs reversed copy.
+   * @returns {VelociousDatabaseQueryOrderPlain} - A new independent order reversing the effective (rendered) direction; a directionless plain order renders DESC.
+   */
+  reversedCopy() {
+    const effective = this.reverseOrder ? `${this.plain} DESC` : this.plain
+    const match = effective.match(/^(.*\S)\s+(ASC|DESC)$/i)
+
+    if (match) {
+      const direction = match[2].toUpperCase() == "ASC" ? "DESC" : "ASC"
+      return new VelociousDatabaseQueryOrderPlain(this.query, `${match[1]} ${direction}`)
+    }
+
+    return new VelociousDatabaseQueryOrderPlain(this.query, `${effective} DESC`)
+  }
+
   toSql() {
     if (this.reverseOrder) {
       return `${this.plain} DESC`

package/src/testing/browser-frontend-tenant-database-scenarios.js

@@ -0,0 +1,158 @@
+// @ts-check
+
+import Configuration, { CurrentConfigurationNotSetError } from "../configuration.js"
+import DatabaseRecord from "../database/record/index.js"
+import BrowserEnvironmentHandler from "../environment-handlers/browser.js"
+import Migration from "../database/migration/index.js"
+import SingleMultiUsePool from "../database/pool/single-multi-use.js"
+import SqliteWebDriver from "../database/drivers/sqlite/index.web.js"
+import Tenant from "../tenants/tenant.js"
+
+const DATABASE_IDENTIFIER = "projectTenant"
+const SCHEMA_GENERATION = "frontend-tenant-browser-persistence-1"
+
+/**
+ * Returns the current configuration without requiring one to exist.
+ * @returns {Configuration | undefined} Current configuration when installed.
+ */
+function currentConfigurationOrUndefined() {
+  try {
+    return Configuration.current()
+  } catch (error) {
+    if (!(error instanceof CurrentConfigurationNotSetError)) throw error
+
+    return undefined
+  }
+}
+
+/**
+ * Builds the real browser-backed two-project configuration.
+ * @returns {Configuration} Browser tenant configuration.
+ */
+function buildConfiguration() {
+  return new Configuration({
+    database: {
+      test: {
+        projectTenant: {
+          driver: SqliteWebDriver,
+          locateFile: () => "/sql-wasm.wasm",
+          migrations: true,
+          name: "velocious-browser-project-proof-template",
+          poolType: SingleMultiUsePool,
+          tenantOnly: true,
+          type: "sqlite"
+        }
+      }
+    },
+    directory: "/frontend-tenant-browser-persistence-scenario",
+    environment: "test",
+    environmentHandler: new BrowserEnvironmentHandler(),
+    frontendTenantSqlite: {maxOpenHandles: 2},
+    initializeModels: async () => {},
+    locale: "en",
+    localeFallbacks: {en: ["en"]},
+    locales: ["en"],
+    tenantDatabaseResolver: ({identifier, tenant}) => {
+      if (identifier !== DATABASE_IDENTIFIER || !tenant || typeof tenant !== "object") return
+      const projectSlug = /** @type {{projectSlug?: string}} */ (tenant).projectSlug
+
+      if (projectSlug !== "alpha" && projectSlug !== "beta") return
+
+      return {name: `velocious-browser-project-proof-${projectSlug}`}
+    }
+  })
+}
+
+/**
+ * Exercises two durable physical tenant databases inside the real browser.
+ * @returns {Promise<{alphaNames: ReturnType<typeof JSON.parse>[], betaNames: ReturnType<typeof JSON.parse>[], identitiesAreDistinct: boolean, openCount: number}>} Serializable proof result.
+ */
+export default async function runFrontendTenantDatabasePersistenceScenario() {
+  const previousConfiguration = currentConfigurationOrUndefined()
+  const configuration = buildConfiguration()
+
+  class BrowserProjectRecord extends DatabaseRecord {}
+  class CreateBrowserProjectRecords extends Migration {
+    async up() {
+      await this.execute("CREATE TABLE browser_project_records(id integer PRIMARY KEY AUTOINCREMENT, name varchar(255) NOT NULL)")
+    }
+  }
+
+  BrowserProjectRecord.setTableName("browser_project_records")
+  BrowserProjectRecord.switchesTenantDatabase(DATABASE_IDENTIFIER)
+  BrowserProjectRecord.registerRecordClass({configuration})
+  CreateBrowserProjectRecords.onDatabases([DATABASE_IDENTIFIER])
+
+  const migrationFile = "20260919090000-create-browser-project-records.js"
+  /**
+   * Loads the one migration bundled into this browser proof.
+   * @type {import("../database/migrator/types.js").RequireMigrationContextType}
+   */
+  const migrations = (fileName) => {
+    if (fileName !== migrationFile) throw new Error(`Unknown browser tenant proof migration: ${fileName}`)
+
+    return {default: CreateBrowserProjectRecords}
+  }
+
+  migrations.keys = () => [migrationFile]
+  migrations.id = "frontend-tenant-browser-persistence-scenario"
+
+  const alpha = Tenant.handle({projectSlug: "alpha"}, configuration)
+  const beta = Tenant.handle({projectSlug: "beta"}, configuration)
+
+  configuration.setCurrent()
+
+  try {
+    await Promise.all([
+      alpha.delete({databaseIdentifier: DATABASE_IDENTIFIER}),
+      beta.delete({databaseIdentifier: DATABASE_IDENTIFIER})
+    ])
+    await Promise.all([
+      alpha.initialize({databaseIdentifier: DATABASE_IDENTIFIER, migrations, schemaGeneration: SCHEMA_GENERATION}),
+      beta.initialize({databaseIdentifier: DATABASE_IDENTIFIER, migrations, schemaGeneration: SCHEMA_GENERATION})
+    ])
+
+    for (let index = 0; index < 12; index++) {
+      await Promise.all([
+        alpha.databaseOperation({databaseIdentifier: DATABASE_IDENTIFIER}, async (operation) => {
+          await operation.forModel(BrowserProjectRecord).create({name: `alpha-${index}`})
+        }),
+        beta.databaseOperation({databaseIdentifier: DATABASE_IDENTIFIER}, async (operation) => {
+          await operation.forModel(BrowserProjectRecord).create({name: `beta-${index}`})
+        })
+      ])
+    }
+
+    await Promise.all([
+      alpha.close({databaseIdentifier: DATABASE_IDENTIFIER, flush: true}),
+      beta.close({databaseIdentifier: DATABASE_IDENTIFIER, flush: true})
+    ])
+    await Promise.all([
+      alpha.initialize({databaseIdentifier: DATABASE_IDENTIFIER, migrations, schemaGeneration: SCHEMA_GENERATION}),
+      beta.initialize({databaseIdentifier: DATABASE_IDENTIFIER, migrations, schemaGeneration: SCHEMA_GENERATION})
+    ])
+
+    const [alphaNames, betaNames] = await Promise.all([
+      alpha.databaseOperation({databaseIdentifier: DATABASE_IDENTIFIER}, async (operation) => {
+        return await operation.forModel(BrowserProjectRecord).order("id").pluck("name")
+      }),
+      beta.databaseOperation({databaseIdentifier: DATABASE_IDENTIFIER}, async (operation) => {
+        return await operation.forModel(BrowserProjectRecord).order("id").pluck("name")
+      })
+    ])
+
+    return {
+      alphaNames,
+      betaNames,
+      identitiesAreDistinct: alpha.databaseIdentity(DATABASE_IDENTIFIER) !== beta.databaseIdentity(DATABASE_IDENTIFIER),
+      openCount: configuration.inspectFrontendTenantSqliteHandles().openCount
+    }
+  } finally {
+    await Promise.all([
+      alpha.delete({databaseIdentifier: DATABASE_IDENTIFIER}),
+      beta.delete({databaseIdentifier: DATABASE_IDENTIFIER})
+    ])
+    if (previousConfiguration) previousConfiguration.setCurrent()
+    await configuration.closeDatabaseConnections()
+  }
+}

package/src/testing/browser-test-app.js

@@ -3,6 +3,7 @@
 import SystemTestBrowserHelper from "system-testing/build/system-test-browser-helper.js"
 import BrowserEnvironmentHandler from "../environment-handlers/browser.js"
 import runFrontendModelEventHookScenario from "./browser-frontend-model-event-hook-scenarios.js"
+import runFrontendTenantDatabasePersistenceScenario from "./browser-frontend-tenant-database-scenarios.js"
 import runUseDatabaseSelectionTransitionScenario from "./browser-use-database-hook-scenarios.js"
 
 const root = document.getElementById("root") || (() => {
@@ -29,6 +30,7 @@ systemTestBrowserHelper.enableOnBrowser()
 Object.assign(globalThis, {velociousBrowserTest: {
   BrowserEnvironmentHandler,
   runFrontendModelEventHookScenario,
+  runFrontendTenantDatabasePersistenceScenario,
   runUseDatabaseSelectionTransitionScenario,
   systemTestBrowserHelper
 }})