@cavulsqa/create 0.1.0

package/templates/f7-app/tests/sales.repository.test.ts

@@ -0,0 +1,329 @@
+import { beforeEach, expect, test } from "vite-plus/test";
+import { Kysely } from "kysely";
+import { Migrator } from "kysely/migration";
+import { createSqlJsDialect } from "@cavulsqa/mobile-db/testing";
+import {
+  advanceOrderStatus,
+  clearAll,
+  createOrder,
+  ensureReferenceData,
+  listCustomers,
+  loadDashboardStats,
+  searchOrders,
+  seedSampleData,
+  deleteOrder,
+  nextOrderReference,
+  saveOrder,
+  setOrderStatus,
+  loadOrderDetail,
+} from "../src/domains/sales/sales.repository.js";
+import { migrations } from "../src/shared/database/migrations.js";
+import type { Database } from "../src/shared/database/schema.js";
+
+/**
+ * The queries run against real SQLite here - sql.js, the same dialect the packages use for their own
+ * tests - so the joins, the aggregates and the migration are executed rather than just type-checked.
+ * A schema this template ships broken would cost whoever generates from it an afternoon.
+ */
+let db: Kysely<Database>;
+
+beforeEach(async () => {
+  db = new Kysely<Database>({ dialect: await createSqlJsDialect() });
+  await new Migrator({
+    db,
+    provider: { getMigrations: () => Promise.resolve(migrations) },
+  }).migrateToLatest();
+});
+
+test("the migration creates every table the schema declares", async () => {
+  const tables = await db.introspection.getTables();
+  const names = tables.map((table) => table.name).sort();
+
+  expect(names).toContain("customer");
+  expect(names).toContain("product");
+  expect(names).toContain("sales_order");
+  expect(names).toContain("order_line");
+  expect(names).toContain("tag");
+  expect(names).toContain("customer_tag");
+});
+
+test("an empty database reports zeroes rather than nulls", async () => {
+  expect(await loadDashboardStats(db)).toEqual({
+    customers: 0,
+    products: 0,
+    orders: 0,
+    draft: 0,
+    confirmed: 0,
+    delivered: 0,
+    revenueCents: 0,
+    committedCents: 0,
+  });
+});
+
+/**
+ * The app seeds this at startup, so it runs on every launch. Running twice has to leave the same
+ * database it left the first time, or a second launch doubles the catalogue.
+ */
+test("reference data gives the app a catalogue and customers, and is idempotent", async () => {
+  await ensureReferenceData(db);
+  const first = await loadDashboardStats(db);
+
+  expect(first.products).toBeGreaterThan(0);
+  expect(first.customers).toBeGreaterThan(0);
+  // Reference data is what you need to write an order, not orders themselves.
+  expect(first.orders).toBe(0);
+
+  await ensureReferenceData(db);
+  expect(await loadDashboardStats(db)).toEqual(first);
+});
+
+test("seeding adds demo orders on top of the reference data", async () => {
+  await ensureReferenceData(db);
+  const before = await loadDashboardStats(db);
+
+  await seedSampleData(db, 4);
+  const stats = await loadDashboardStats(db);
+
+  expect(stats.customers).toBe(before.customers + 4);
+  expect(stats.products).toBe(before.products);
+  // Two orders per customer the seed adds.
+  expect(stats.orders).toBe(8);
+  expect(stats.revenueCents).toBeGreaterThan(0);
+});
+
+test("the order list joins the customer and totals its lines", async () => {
+  await seedSampleData(db, 2);
+  const orders = await searchOrders(db, "");
+
+  expect(orders.length).toBe(4);
+  const first = orders[0];
+  expect(first?.customerName).toMatch(/^Customer /);
+  expect(first?.city.length).toBeGreaterThan(0);
+  expect(first?.lines).toBeGreaterThan(0);
+  expect(first?.totalCents).toBeGreaterThan(0);
+});
+
+test("search filters on the customer name and the reference together", async () => {
+  await seedSampleData(db, 3);
+  const all = await searchOrders(db, "");
+
+  // Taken from the data rather than hard-coded: the reference customers are numbered first, so the
+  // ones the seed adds do not start at 1.
+  const name = all[0]?.customerName ?? "";
+  const byCustomer = await searchOrders(db, name);
+  expect(byCustomer.length).toBeGreaterThan(0);
+  expect(byCustomer.every((order) => order.customerName === name)).toBe(true);
+
+  const reference = all[0]?.reference ?? "";
+  const byReference = await searchOrders(db, reference);
+  expect(byReference.some((order) => order.reference === reference)).toBe(true);
+
+  expect(await searchOrders(db, "nothing-matches-this")).toEqual([]);
+});
+
+test("advancing a status cycles draft to confirmed to delivered and back", async () => {
+  await seedSampleData(db, 1);
+  const [order] = await searchOrders(db, "");
+  const id = order?.id ?? 0;
+
+  expect(order?.status).toBe("draft");
+
+  await advanceOrderStatus(db, id);
+  expect((await searchOrders(db, "")).find((row) => row.id === id)?.status).toBe("confirmed");
+
+  await advanceOrderStatus(db, id);
+  expect((await searchOrders(db, "")).find((row) => row.id === id)?.status).toBe("delivered");
+
+  await advanceOrderStatus(db, id);
+  expect((await searchOrders(db, "")).find((row) => row.id === id)?.status).toBe("draft");
+});
+
+test("advancing an order that does not exist is a no-op, not a throw", async () => {
+  await expect(advanceOrderStatus(db, 9999)).resolves.toBeUndefined();
+});
+
+test("customers come back ordered by name", async () => {
+  await seedSampleData(db, 3);
+  const customers = await listCustomers(db);
+  const names = customers.map((customer) => customer.name);
+
+  expect(names).toEqual([...names].sort());
+});
+
+test("clearing leaves every table empty", async () => {
+  await seedSampleData(db, 3);
+  await clearAll(db);
+
+  expect(await loadDashboardStats(db)).toEqual({
+    customers: 0,
+    products: 0,
+    orders: 0,
+    draft: 0,
+    confirmed: 0,
+    delivered: 0,
+    revenueCents: 0,
+    committedCents: 0,
+  });
+  expect(await searchOrders(db, "")).toEqual([]);
+});
+
+test("an order's total is quantity times unit price, summed over its lines", async () => {
+  await db
+    .insertInto("customer")
+    .values({ created_at: "now", name: "Solo", city: "Oran" })
+    .execute();
+  await db
+    .insertInto("product")
+    .values({ created_at: "now", name: "Widget", price_cents: 1000 })
+    .execute();
+
+  const customer = await db.selectFrom("customer").select("id").executeTakeFirstOrThrow();
+  const product = await db
+    .selectFrom("product")
+    .select(["id", "price_cents"])
+    .executeTakeFirstOrThrow();
+
+  // Two lines, quantities 1 and 2 at 1000 each: 1000 + 2000.
+  await createOrder(db, customer.id, [product, product]);
+
+  const [order] = await searchOrders(db, "");
+  expect(order?.lines).toBe(2);
+  expect(order?.totalCents).toBe(3000);
+});
+
+test("committed revenue counts only confirmed and delivered orders", async () => {
+  await seedSampleData(db, 2);
+  const before = await loadDashboardStats(db);
+
+  // Everything starts as a draft, so nothing is committed yet.
+  expect(before.draft).toBe(4);
+  expect(before.committedCents).toBe(0);
+  expect(before.revenueCents).toBeGreaterThan(0);
+
+  const [first] = await searchOrders(db, "");
+  await setOrderStatus(db, first?.id ?? 0, "confirmed");
+
+  const after = await loadDashboardStats(db);
+  expect(after.draft).toBe(3);
+  expect(after.confirmed).toBe(1);
+  expect(after.committedCents).toBe(first?.totalCents ?? -1);
+});
+
+test("the next reference counts up and survives a deletion without reuse", async () => {
+  expect(await nextOrderReference(db)).toBe("SO-0001");
+
+  const customer = await db
+    .insertInto("customer")
+    .values({ created_at: "now", name: "Solo", city: "Oran" })
+    .returning("id")
+    .executeTakeFirstOrThrow();
+  await db
+    .insertInto("product")
+    .values({ created_at: "now", name: "Widget", price_cents: 500 })
+    .execute();
+  const product = await db.selectFrom("product").select("id").executeTakeFirstOrThrow();
+
+  await saveOrder(db, {
+    customerId: customer.id,
+    reference: "SO-0001",
+    lines: [{ productId: product.id, quantity: 2, unitPriceCents: 500 }],
+  });
+  expect(await nextOrderReference(db)).toBe("SO-0002");
+
+  await saveOrder(db, {
+    customerId: customer.id,
+    reference: "SO-0002",
+    lines: [{ productId: product.id, quantity: 1, unitPriceCents: 500 }],
+  });
+
+  // Removing the highest must not hand the same reference out twice.
+  const orders = await searchOrders(db, "SO-0002");
+  await deleteOrder(db, orders[0]?.id ?? 0);
+  expect(await nextOrderReference(db)).toBe("SO-0002");
+});
+
+test("saving writes the order and all of its lines together", async () => {
+  const customer = await db
+    .insertInto("customer")
+    .values({ created_at: "now", name: "Solo", city: "Oran" })
+    .returning("id")
+    .executeTakeFirstOrThrow();
+  await db
+    .insertInto("product")
+    .values({ created_at: "now", name: "Widget", price_cents: 250 })
+    .execute();
+  const product = await db.selectFrom("product").select("id").executeTakeFirstOrThrow();
+
+  await saveOrder(db, {
+    customerId: customer.id,
+    reference: "SO-0007",
+    lines: [
+      { productId: product.id, quantity: 3, unitPriceCents: 250 },
+      { productId: product.id, quantity: 1, unitPriceCents: 250 },
+    ],
+  });
+
+  const [order] = await searchOrders(db, "SO-0007");
+  expect(order?.lines).toBe(2);
+  expect(order?.totalCents).toBe(1000);
+  expect(order?.status).toBe("draft");
+});
+
+test("deleting an order takes its lines with it", async () => {
+  await seedSampleData(db, 1);
+  const [order] = await searchOrders(db, "");
+  const id = order?.id ?? 0;
+
+  await deleteOrder(db, id);
+
+  expect((await searchOrders(db, "")).some((row) => row.id === id)).toBe(false);
+  const orphans = await db
+    .selectFrom("order_line")
+    .select("id")
+    .where("order_id", "=", id)
+    .execute();
+  expect(orphans).toEqual([]);
+});
+
+test("seeding twice adds customers without duplicating the catalogue or throwing", async () => {
+  await seedSampleData(db, 2);
+  const first = await loadDashboardStats(db);
+
+  // This threw "UNIQUE constraint failed: tag.label" before the seed became additive.
+  await seedSampleData(db, 2);
+  const second = await loadDashboardStats(db);
+
+  expect(second.customers).toBe(first.customers + 2);
+  expect(second.orders).toBe(first.orders + 4);
+  // The catalogue is fixed, so a second press must not double it.
+  expect(second.products).toBe(first.products);
+
+  const tags = await db.selectFrom("tag").select("label").execute();
+  expect(new Set(tags.map((tag) => tag.label)).size).toBe(tags.length);
+
+  const names = (await listCustomers(db)).map((customer) => customer.name);
+  expect(new Set(names).size).toBe(names.length);
+});
+
+test("the order detail reads its lines, product names and customer tags", async () => {
+  await seedSampleData(db, 1);
+  const [row] = await searchOrders(db, "");
+  const detail = await loadOrderDetail(db, row?.id ?? 0);
+
+  expect(detail?.reference).toBe(row?.reference);
+  expect(detail?.customerName).toBe(row?.customerName);
+  expect(detail?.lines.length).toBe(row?.lines);
+  expect(detail?.lines.every((line) => line.productName.length > 0)).toBe(true);
+  expect(detail?.totalCents).toBe(row?.totalCents);
+  // Seeding attaches one tag per customer.
+  expect(detail?.tags.length).toBeGreaterThan(0);
+
+  // Each line total is quantity times unit price.
+  for (const line of detail?.lines ?? []) {
+    expect(line.lineTotalCents).toBe(line.quantity * line.unitPriceCents);
+  }
+});
+
+test("the order detail is null for an id that does not exist", async () => {
+  expect(await loadOrderDetail(db, 4242)).toBeNull();
+});

package/templates/f7-app/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "lib": ["ESNext", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "jsx": "preserve",
+    "strict": true,
+    "noUnusedLocals": true,
+    "noEmit": true,
+    "isolatedModules": true,
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+    "types": ["vite/client"],
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "include": ["src/**/*.ts", "src/**/*.vue", "auto-imports.d.ts", "components.d.ts"]
+}

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

@@ -0,0 +1,14 @@
+{
+  "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"]
+}

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

@@ -0,0 +1,95 @@
+import { readFileSync } from "node:fs";
+import { fileURLToPath, URL } from "node:url";
+import VueI18nPlugin from "@intlify/unplugin-vue-i18n/vite";
+import tailwindcss from "@tailwindcss/vite";
+import vue from "@vitejs/plugin-vue";
+import AutoImport from "unplugin-auto-import/vite";
+import Icons from "unplugin-icons/vite";
+import IconsResolver from "unplugin-icons/resolver";
+import Components from "unplugin-vue-components/vite";
+import { defineConfig } from "vite-plus";
+import {
+  Framework7VueResolver,
+  getFramework7AutoImports,
+} from "./src/shared/utils/resolvers/resolvers.js";
+
+const SRC = fileURLToPath(new URL("./src", import.meta.url));
+
+// Read once so Settings can show the real name and version without importing the manifest
+// into the bundle.
+const pkg = JSON.parse(
+  readFileSync(fileURLToPath(new URL("./package.json", import.meta.url)), "utf-8"),
+) as { name: string; version: string };
+
+export default defineConfig({
+  define: {
+    __APP_NAME__: JSON.stringify("App"),
+    __APP_VERSION__: JSON.stringify(pkg.version),
+  },
+
+  plugins: [
+    vue({
+      template: {
+        compilerOptions: {
+          // jeep-sqlite is a custom element, not a Vue component.
+          isCustomElement: (tag) => tag === "jeep-sqlite" || tag.startsWith("swiper-"),
+        },
+      },
+    }),
+
+    tailwindcss(),
+
+    Icons({ autoInstall: true, compiler: "vue3" }),
+
+    VueI18nPlugin({
+      include: [fileURLToPath(new URL("./src/locales/**", import.meta.url))],
+    }),
+
+    /**
+     * Composition API, i18n, vueuse and the Framework7 helpers are available without an import
+     * line. `auto-imports.d.ts` and `components.d.ts` are generated on first run and are what makes
+     * the editor, `vue-tsc` and the build agree - they are artifacts, not files to hand-edit.
+     */
+    AutoImport({
+      include: [/\.[tj]sx?$/, /\.vue$/, /\.vue\?vue/],
+      imports: ["vue", "vue-i18n", "@vueuse/core", getFramework7AutoImports()],
+      dirs: [
+        "src/shared/composables/**",
+        "src/shared/utils/**",
+        "src/plugins/**",
+        "src/modules/**/composables/**",
+      ],
+      dts: "auto-imports.d.ts",
+      vueTemplate: true,
+      viteOptimizeDeps: true,
+      injectAtEnd: true,
+      dirsScanOptions: { types: true },
+    }),
+
+    /**
+     * `Framework7VueResolver` is why no screen imports an `f7-*` component and why the app never
+     * calls `registerComponents`: each component is pulled from `framework7-vue` exactly where it
+     * is used. Icons resolve through the same pass, so `<i-f7-house-fill />` needs no import.
+     */
+    Components({
+      dts: "components.d.ts",
+      dirs: ["src/shared/components/**", "src/modules/**/views/**", "src/modules/**/components/**"],
+      extensions: ["vue", "ts"],
+      deep: true,
+      resolvers: [
+        Framework7VueResolver(),
+        IconsResolver({
+          prefix: "i",
+          alias: { f7: "framework7", mt: "material-symbols" },
+          enabledCollections: ["framework7", "material-symbols", "lucide"],
+        }),
+      ],
+    }),
+  ],
+
+  resolve: { alias: { "@": SRC } },
+  server: { port: 5173 },
+  build: { target: "esnext" },
+  lint: { options: { typeAware: false } },
+  fmt: {},
+});