@cavulsqa/create 2.8.2 → 2.9.2

package/lib/scaffold.mjs

@@ -1,6 +1,7 @@
+import { cpSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { listTemplateFiles } from "./templateFiles.mjs";
 import { pruneEngines } from "./pruneEngines.mjs";
-import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
-import { basename, join } from "node:path";
 
 /** Files whose contents carry the app's identity and have to be rewritten, not copied. */
 function personalise(entry, text, { name, appName }) {
@@ -38,26 +39,12 @@ function manifest(source, { name, appName, templateName }) {
   )}\n`;
 }
 
-/**
- * Installed, generated or platform-specific: none of it belongs in a generated app.
- *
- * A bundled template never contains these, but `--from` points at a live working copy that usually
- * does - and `node_modules` is full of directory symlinks, which `isDirectory()` reports as files and
- * `readFileSync` then rejects with EISDIR. `--from` could not generate anything at all.
- */
-const SKIP = new Set(["node_modules", "dist", "android", "ios", ".git", "pnpm-lock.yaml"]);
-
 function copyTree(from, to, transform) {
-  mkdirSync(to, { recursive: true });
-  for (const entry of readdirSync(from, { withFileTypes: true })) {
-    if (SKIP.has(entry.name)) continue;
-    const source = join(from, entry.name);
-    const target = join(to, entry.name);
-    if (entry.isDirectory()) {
-      copyTree(source, target, transform);
-      continue;
-    }
-    const rewritten = transform(entry.name, source);
+  for (const file of listTemplateFiles(from)) {
+    const source = join(from, file);
+    const target = join(to, file);
+    mkdirSync(dirname(target), { recursive: true });
+    const rewritten = transform(basename(file), source);
     if (rewritten === null) cpSync(source, target);
     else writeFileSync(target, rewritten);
   }

package/lib/templateFiles.mjs

@@ -0,0 +1,62 @@
+import { execFileSync } from "node:child_process";
+import { existsSync, readdirSync } from "node:fs";
+import { join, relative, sep } from "node:path";
+
+/**
+ * Generated, installed or platform-specific: none of it belongs in a template.
+ *
+ * Only consulted when git cannot answer - a bundled template carries no repository.
+ */
+const SKIP = new Set(["node_modules", "dist", "android", "ios", ".git", "pnpm-lock.yaml"]);
+
+/**
+ * The files a template consists of, as paths relative to `dir`.
+ *
+ * Asks git first, and falls back to walking only when git cannot answer. A name blocklist is the
+ * wrong instrument for a working copy: it lets through anything nobody thought to name, and a
+ * maintainer's stray `build/` and a deploy log both reached a generated app that way. Git already
+ * knows what belongs - it is the same list the template fingerprint is computed from, so what ships
+ * and what is hashed cannot drift apart.
+ */
+export function listTemplateFiles(dir) {
+  const tracked = trackedFiles(dir);
+  return tracked ?? walk(dir, dir);
+}
+
+function trackedFiles(dir) {
+  if (!existsSync(join(dir, ".git")) && !insideRepository(dir)) return null;
+  try {
+    const listing = execFileSync("git", ["ls-files", "-z"], {
+      cwd: dir,
+      encoding: "utf8",
+      maxBuffer: 64 * 1024 * 1024,
+    });
+    const files = listing
+      .split("\0")
+      .filter(Boolean)
+      .map((file) => file.split("/").join(sep));
+    return files.length ? files.filter((file) => !SKIP.has(file.split(sep)[0])) : null;
+  } catch {
+    return null;
+  }
+}
+
+function insideRepository(dir) {
+  try {
+    execFileSync("git", ["rev-parse", "--is-inside-work-tree"], { cwd: dir, stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function walk(root, dir) {
+  const found = [];
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    if (SKIP.has(entry.name)) continue;
+    const full = join(dir, entry.name);
+    if (entry.isDirectory()) found.push(...walk(root, full));
+    else found.push(relative(root, full));
+  }
+  return found;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cavulsqa/create",
-  "version": "2.8.2",
+  "version": "2.9.2",
   "description": "Create a Vue + Framework7 + Capacitor + SQLite app from the cavulsqa templates.",
   "keywords": [
     "capacitor",
@@ -52,7 +52,7 @@
       }
     ]
   },
-  "templatesFingerprint": "sha256-OYEjkV6bTfZTtTFsxxtMgXoxM4x7q6/PUS3qfUT/G3k=",
+  "templatesFingerprint": "sha256-w5ItqHFEFJCJwe7V3W0FEhJf7foJkanjYLY85j/Wbd8=",
   "scripts": {
     "build": "node scripts/bundleTemplates.mjs",
     "check": "vp check",

package/templates/f7-app/src/app/storage.config.ts

@@ -37,8 +37,17 @@ export const DEFAULT_ORDER: StorageCandidate[] = [
  * A typo is reported and ignored rather than fatal: it should not brick the build's output, but a
  * setting that was silently dropped looks exactly like one that was applied and did nothing.
  */
+/**
+ * What `VITE_STORAGE_ENGINE` was at build time, or undefined.
+ *
+ * Exported so the open can report it. Vite inlines this when it bundles, so an empty value means
+ * the variable never reached the build - a `.env` written as UTF-16 by PowerShell's `>` parses as
+ * garbage and is dropped without a word.
+ */
+export const preferredEngine = import.meta.env.VITE_STORAGE_ENGINE;
+
 function preferredFirst(candidates: StorageCandidate[]): StorageCandidate[] {
-  const preferred = import.meta.env.VITE_STORAGE_ENGINE;
+  const preferred = preferredEngine;
   if (!preferred) return candidates;
 
   if (!isStorageId(preferred)) {

package/templates/f7-app/src/locales/en.json

@@ -117,7 +117,6 @@
     "footer": "Change these screens in src/modules/settings/.",
     "storage": "Storage",
     "engine": "Database engine",
-    "engineHint": "Every query reaches SQLite compiled to WebAssembly, against a real file in the Origin Private File System, in a worker - no native bridge. The same engine in a browser as on a phone.",
     "webview": "WebView",
     "notDurable": "Storage is not persisted"
   },

package/templates/f7-app/src/locales/fr.json

@@ -117,7 +117,6 @@
     "footer": "Modifiez ces écrans dans src/modules/settings/.",
     "storage": "Stockage",
     "engine": "Moteur de base de données",
-    "engineHint": "Chaque requête atteint SQLite compilé en WebAssembly, sur un vrai fichier dans l'Origin Private File System, dans un worker - sans pont natif. Le même moteur dans un navigateur que sur un téléphone.",
     "webview": "WebView",
     "notDurable": "Le stockage n'est pas persistant"
   },

package/templates/f7-app/src/modules/settings/views/SettingsView.vue

@@ -52,7 +52,7 @@
       </F7ListItem>
     </F7List>
     <F7Block class="mt-0!">
-      <p class="m-0 text-[13px] opacity-60">{{ t("settings.engineHint") }}</p>
+      <p class="m-0 text-[13px] opacity-60">{{ tradeoff }}</p>
     </F7Block>
 
     <F7BlockTitle>{{ t("settings.tryIt") }}</F7BlockTitle>

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

@@ -3,7 +3,7 @@ import { Migrator } from "kysely/migration";
 import { runWrite, type MobileDatabase } from "@cavulsqa/mobile-db";
 import { createChangeBus, createReactiveDb } from "@cavulsqa/reactive-db";
 import { pragmaProfile, pragmasFor } from "@/app/pragmas.config";
-import { storageChain } from "@/app/storage.config";
+import { preferredEngine, storageChain } from "@/app/storage.config";
 import { isStorageId, type StorageAttempt, type StorageCandidate } from "./candidates";
 import { migrations } from "./migrations";
 import { describeOpenFailure } from "./storage";
@@ -155,6 +155,14 @@ async function tryEveryCandidate(): Promise<MobileDatabase<Database>> {
       applied = opened.pragmas;
       chosen = candidate;
       attempts.push({ id: candidate.id, outcome: "opened" });
+      // Every launch names its engine. A preference that never arrived - a `.env` the build could
+      // not parse, a typo - otherwise looks exactly like one that was applied, and the app reports
+      // an engine nobody chose.
+      console.info(
+        `[storage] opened on ${candidate.id}` +
+          (preferredEngine ? ` (VITE_STORAGE_ENGINE=${preferredEngine})` : " (no preference set)"),
+        attempts,
+      );
       return database;
     } catch (error) {
       attempts.push({ id: candidate.id, outcome: "failed", detail: describeOpenFailure(error) });

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

@@ -91,5 +91,13 @@ export default defineConfig({
   server: { port: 5173 },
   build: { target: "esnext" },
   lint: { options: { typeAware: false } },
-  fmt: {},
+  /**
+   * The unplugin declaration files are committed - vue-tsc has no idea what `ref` or an F7
+   * component is without them - but the generator rewrites them on every run, and what it emits is
+   * not what oxfmt emits. Formatting them means a build and a commit hook take turns rewriting a
+   * file no human wrote and no human can keep formatted.
+   */
+  fmt: {
+    ignorePatterns: ["**/auto-imports.d.ts", "**/components.d.ts"],
+  },
 });