@cavulsqa/create 0.1.2 → 2.2.1

package/templates/f7-app/src/shared/database/wa.worker.ts

@@ -0,0 +1,5 @@
+import { runWaWorker } from "@cavulsqa/mobile-db/wa";
+
+// The whole worker. It lives in the app because only the app's bundler can emit a worker and the
+// wa-sqlite wasm it loads; the logic is all in @cavulsqa/mobile-db.
+runWaWorker();

package/templates/f7-app/src/shared/utils/resolvers/resolvers.ts

@@ -14,8 +14,7 @@ export function Framework7VueResolver(): ComponentResolver {
     "f7-nav-title",
     "f7-nav-title-large",
     "f7-toolbar",
-    // No "f7-toolbar-pane": Framework7 9 ships the CSS class but framework7-vue 8 exports no
-    // such component, and resolving it fails at runtime instead of warning. Use the class.
+    "f7-toolbar-pane",
     "f7-subnavbar",
     "f7-searchbar",
 

package/templates/f7-app/tests/benchmark.suite.test.ts

@@ -0,0 +1,104 @@
+import { expect, test } from "vite-plus/test";
+import { Kysely } from "kysely";
+import { Migrator } from "kysely/migration";
+import { createSqlJsDialect } from "@cavulsqa/mobile-db/testing";
+import { runBenchmark } from "../src/domains/benchmark/benchmark.suite.js";
+import { datasetRowCount, SCALE, TOTAL_ROWS } from "../src/domains/benchmark/benchmark.dataset.js";
+import { migrations } from "../src/shared/database/migrations.js";
+import type { Database } from "../src/shared/database/schema.js";
+
+async function open(): Promise<Kysely<Database>> {
+  const db = new Kysely<Database>({ dialect: await createSqlJsDialect() });
+  await new Migrator({
+    db,
+    provider: { getMigrations: () => Promise.resolve(migrations) },
+  }).migrateToLatest();
+  return db;
+}
+
+/**
+ * The suite seeds roughly 100k rows across ten tables and runs 24 cases, several of them six-table
+ * joins. A broken case would otherwise surface halfway through a run on a phone, as a number nobody
+ * could interpret - so it executes here against real SQLite first.
+ *
+ * Slow by design: this is the only place the whole thing runs without a device.
+ */
+test("the whole suite runs at scale and every case reports a timing", async () => {
+  const db = await open();
+
+  const seen: string[] = [];
+  const result = await runBenchmark(db, (name) => seen.push(name));
+
+  expect(result.cases.length).toBeGreaterThanOrEqual(27);
+  expect(result.seedMs, "the first run builds the dataset").toBeGreaterThan(0);
+  expect(result.rowsSeeded).toBeGreaterThanOrEqual(SCALE.orderLines + SCALE.stock);
+
+  for (const entry of result.cases) {
+    expect(entry.operations, entry.name).toBeGreaterThan(0);
+    expect(entry.msPerOperation, entry.name).toBeGreaterThanOrEqual(0);
+    expect(entry.worstMs, entry.name).toBeGreaterThanOrEqual(entry.medianMs);
+  }
+
+  // All six groups represented, or the suite is not covering what it claims to.
+  expect([...new Set(result.cases.map((entry) => entry.group))].sort()).toEqual([
+    "concurrency",
+    "join",
+    "read",
+    "schema",
+    "sync",
+    "transaction",
+    "write",
+  ]);
+
+  /**
+   * The sync cases measure how long a read waits, so a zero would mean the read never queued behind
+   * the write and the case proved nothing.
+   */
+  for (const entry of result.cases.filter((c) => c.group === "sync")) {
+    expect(entry.medianMs, entry.name).toBeGreaterThan(0);
+  }
+
+  // Read and join cases must actually return rows; a fast case that returns none proves nothing.
+  for (const entry of result.cases.filter((c) => c.group === "join")) {
+    expect(entry.rows, `${entry.name} returned no rows`).toBeGreaterThan(0);
+  }
+}, 600_000);
+
+/**
+ * The dataset has to survive a run untouched, or every subsequent run measures a different database
+ * and two runs cannot be compared.
+ */
+test("a run leaves the dataset exactly as it found it", async () => {
+  const db = await open();
+  await runBenchmark(db);
+  const after = await datasetRowCount(db);
+
+  await runBenchmark(db);
+  expect(await datasetRowCount(db)).toBe(after);
+
+  // And nothing the write cases created is left behind.
+  const strays = await db
+    .selectFrom("bench_payment")
+    .select(({ fn }) => fn.countAll<number>().as("n"))
+    .where("method", "like", "bench-%")
+    .executeTakeFirstOrThrow();
+  expect(Number(strays.n)).toBe(0);
+}, 600_000);
+
+test("the scale constants add up to about 100k rows", () => {
+  expect(TOTAL_ROWS).toBeGreaterThan(100_000);
+  expect(SCALE.orderLines).toBe(40_000);
+});
+
+test("the benchmark never touches the app's tables", async () => {
+  const db = await open();
+  await db
+    .insertInto("customer")
+    .values({ created_at: "2026-01-01T00:00:00.000Z", name: "Untouched", city: "Algiers" })
+    .execute();
+
+  await runBenchmark(db);
+
+  const customers = await db.selectFrom("customer").select("name").execute();
+  expect(customers.map((row) => row.name)).toEqual(["Untouched"]);
+}, 600_000);

package/templates/f7-app/tests/migrations.test.ts

@@ -0,0 +1,74 @@
+import { expect, test } from "vite-plus/test";
+import { Kysely } from "kysely";
+import { Migrator } from "kysely/migration";
+import { createSqlJsDialect } from "@cavulsqa/mobile-db/testing";
+import { migrations } from "../src/shared/database/migrations.js";
+import type { Database } from "../src/shared/database/schema.js";
+
+async function migrate(db: Kysely<Database>, set = migrations) {
+  return new Migrator({
+    db,
+    provider: { getMigrations: () => Promise.resolve(set) },
+  }).migrateToLatest();
+}
+
+test("a fresh database gets every table the schema declares", async () => {
+  const db = new Kysely<Database>({ dialect: await createSqlJsDialect() });
+  const result = await migrate(db);
+  expect(result.error).toBeUndefined();
+
+  const names = (await db.introspection.getTables()).map((t) => t.name);
+  for (const table of [
+    "customer",
+    "product",
+    "sales_order",
+    "order_line",
+    "tag",
+    "customer_tag",
+    "bench_region",
+    "bench_city",
+    "bench_customer",
+    "bench_category",
+    "bench_product",
+    "bench_warehouse",
+    "bench_stock",
+    "bench_order",
+    "bench_order_line",
+    "bench_payment",
+  ]) {
+    expect(names, table).toContain(table);
+  }
+
+  // The two-table benchmark 003 replaced must be gone, not merely unused.
+  expect(names).not.toContain("bench_parent");
+  expect(names).not.toContain("bench_child");
+});
+
+/**
+ * The failure this exists for: deleting an already-applied migration instead of emptying it. Kysely
+ * records applied migrations by key, so a recorded key the provider no longer offers makes it refuse
+ * the entire set - applying nothing, reporting the error in its return value rather than throwing,
+ * and leaving an app whose first query fails with "no such table".
+ */
+test("dropping an applied migration is refused, and the refusal is visible", async () => {
+  const db = new Kysely<Database>({ dialect: await createSqlJsDialect() });
+  expect((await migrate(db)).error).toBeUndefined();
+
+  const { "002_benchmark": _removed, ...withoutTombstone } = migrations;
+  const result = await migrate(db, withoutTombstone);
+
+  expect(result.error, "kysely must object to the missing migration").toBeDefined();
+});
+
+test("running twice is a no-op, and every key is still there", async () => {
+  const db = new Kysely<Database>({ dialect: await createSqlJsDialect() });
+  const first = await migrate(db);
+  const second = await migrate(db);
+
+  expect(first.error).toBeUndefined();
+  expect(second.error).toBeUndefined();
+  expect(second.results ?? []).toEqual([]);
+
+  // The tombstone counts: a key may stop doing work but may not stop existing.
+  expect(Object.keys(migrations)).toEqual(["001_sales", "002_benchmark", "003_benchmark_scale"]);
+});

package/templates/f7-app/tests/storage.test.ts

@@ -0,0 +1,117 @@
+import { afterEach, expect, test } from "vite-plus/test";
+import { DEFAULT_ORDER, storageChain } from "../src/app/storage.config.js";
+import {
+  describeOpenFailure,
+  MINIMUM_CHROMIUM_FOR_OPFS,
+  probeOpfsCapable,
+  webviewLikelyTooOld,
+  webviewVersion,
+} from "../src/shared/database/storage.js";
+
+const original = globalThis.navigator;
+
+afterEach(() => {
+  if (original)
+    Object.defineProperty(globalThis, "navigator", { value: original, configurable: true });
+});
+
+function withNavigator(value: unknown): void {
+  Object.defineProperty(globalThis, "navigator", { value, configurable: true });
+}
+
+/**
+ * The regression this exists for: the probe used to require `createSyncAccessHandle` on
+ * `FileSystemFileHandle.prototype`. That method is Worker-only in Chromium, so it is absent on the
+ * main thread of every device - and the check rejected a phone on WebView 150 that had been running
+ * OPFS for hours. A main-thread probe may only look at what the main thread can see.
+ */
+test("a WebView that supports OPFS passes even without the worker-only method", () => {
+  withNavigator({ storage: { getDirectory: () => Promise.resolve({}) } });
+  expect("createSyncAccessHandle" in (globalThis.FileSystemFileHandle?.prototype ?? {})).toBe(
+    false,
+  );
+  expect(probeOpfsCapable().supported).toBe(true);
+});
+
+test("a WebView with no OPFS at all is refused, and told what to do", () => {
+  withNavigator({ storage: {} });
+  const probe = probeOpfsCapable();
+  expect(probe.supported).toBe(false);
+  expect(probe.reason).toMatch(/Android System WebView/);
+});
+
+test("an open failure is translated into something actionable", () => {
+  const sah = describeOpenFailure(new Error("createSyncAccessHandle is not a function"));
+  expect(sah).toMatch(/Android System WebView/);
+  // The other cause of the same failure, and the one a person can actually fix themselves.
+  expect(sah).toMatch(/still holds the database open/);
+  // The engine's own words are kept, so a bug report has something to go on.
+  expect(sah).toContain("createSyncAccessHandle is not a function");
+
+  expect(describeOpenFailure(new Error("disk I/O error"))).toBe(
+    "The database could not be opened: disk I/O error",
+  );
+});
+
+/**
+ * The chain is a claim about ordering, so it is checked like one: fastest first, durable before
+ * volatile, and nothing in it without a stated cost.
+ */
+test("the storage chain is ordered and honest about what each entry costs", () => {
+  expect(storageChain.length).toBeGreaterThan(0);
+
+  // The ranking is asserted against the default order, not the live chain: VITE_STORAGE_ENGINE
+  // reorders the chain on purpose, and a generated app that chose another engine is not broken.
+  expect(DEFAULT_ORDER[0]?.id).toBe("sqlite-wasm-opfs-sahpool");
+  expect(DEFAULT_ORDER[0]?.evidence).toBe("measured");
+
+  // Whatever the environment asked for, the chain must still be every candidate exactly once -
+  // promoting one may not drop the others, or the fallback silently disappears.
+  expect([...storageChain].sort((a, b) => (a.id < b.id ? -1 : 1))).toEqual(
+    [...DEFAULT_ORDER].sort((a, b) => (a.id < b.id ? -1 : 1)),
+  );
+
+  for (const candidate of DEFAULT_ORDER) {
+    expect(candidate.tradeoff.length, candidate.id).toBeGreaterThan(20);
+    expect(candidate.label.length, candidate.id).toBeGreaterThan(5);
+  }
+
+  // Nothing in the chain may be volatile: a silent stop somewhere data is not kept is worse than
+  // an error that names every attempt.
+  expect(storageChain.filter((candidate) => !candidate.durable)).toEqual([]);
+
+  // Every engine gets a probe of its own; sharing one would hide that IndexedDB needs no OPFS.
+  expect(storageChain.every((candidate) => typeof candidate.probe === "function")).toBe(true);
+
+  // Ids are unique, or results keyed by id would overwrite each other.
+  expect(new Set(storageChain.map((c) => c.id)).size).toBe(storageChain.length);
+});
+
+/** The floor is reported, never enforced: a vendor build can differ, so it informs and nothing else. */
+test("the WebView version is read from the user agent and judged against the floor", () => {
+  withNavigator({
+    storage: { getDirectory: () => Promise.resolve({}) },
+    userAgent: "Mozilla/5.0 (Linux; Android 16) AppleWebKit/537.36 Chrome/150.0.7871.183 Mobile",
+  });
+  expect(webviewVersion()).toBe(150);
+  expect(webviewLikelyTooOld()).toBe(false);
+  // Support is still asserted, because the floor must not become a second gate on a working device.
+  expect(probeOpfsCapable().supported).toBe(true);
+
+  withNavigator({
+    storage: { getDirectory: () => Promise.resolve({}) },
+    userAgent: "Mozilla/5.0 (Linux; Android 7.0) AppleWebKit/537.36 Chrome/51.0.2704.90 Mobile",
+  });
+  expect(webviewVersion()).toBe(51);
+  expect(webviewLikelyTooOld()).toBe(true);
+
+  withNavigator({
+    storage: { getDirectory: () => Promise.resolve({}) },
+    userAgent: "something else",
+  });
+  expect(webviewVersion()).toBe(null);
+  // Unknown is not old: an unparseable agent must not lock anybody out.
+  expect(webviewLikelyTooOld()).toBe(false);
+
+  expect(MINIMUM_CHROMIUM_FOR_OPFS).toBe(109);
+});

package/templates/f7-app/vite.config.ts

@@ -41,7 +41,9 @@ export default defineConfig({
 
     Icons({ autoInstall: true, compiler: "vue3" }),
 
-    VueI18nPlugin({ include: [fileURLToPath(new URL("./src/locales/**", import.meta.url))] }),
+    VueI18nPlugin({
+      include: [fileURLToPath(new URL("./src/locales/**", import.meta.url))],
+    }),
 
     /**
      * Composition API, i18n, vueuse and the Framework7 helpers are available without an import

package/templates/f7-app/tsconfig.node.json

@@ -1,14 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "types": ["node"],
-    /**
-     * vite-plus bundles its own Vite while the unplugin packages depend on Vite as a peer, so the
-     * plugin array is compared across two copies of the same types and TS gives up with
-     * "excessive stack depth". `vp check` type-checks this file with a single resolution, so the
-     * comparison never happens there - which is why the app project below leaves it out.
-     */
-    "skipLibCheck": true
-  },
-  "include": ["vite.config.ts"]
-}