@tinycld/bootstrap 1.0.1 → 1.1.1

package/templates/workspace/tests/unit-setup.ts

@@ -0,0 +1,55 @@
+import { vi } from 'vitest'
+
+process.env.EXPO_PUBLIC_ENV ??= 'test'
+
+// tinycld.config.ts is the runtime source of truth, but loading the real one
+// pulls every linked package's collections/screens (and their un-mockable RN
+// surface) into the test graph. Shim it to an empty config so unit tests stay
+// light; tests that need specific packages can override per-file.
+vi.mock('@tinycld/app-generated/tinycld-config', () => ({
+    tinycldConfig: [],
+}))
+
+vi.mock('@sentry/react-native', () => ({
+    init: vi.fn(),
+    captureException: vi.fn(),
+    withScope: vi.fn(),
+}))
+
+// React Native's entry uses Flow syntax Vite/Rollup can't parse. Substitute
+// the minimal surface our tests touch.
+vi.mock('react-native', () => ({
+    Platform: { OS: 'web' },
+    Dimensions: {
+        get: () => ({ width: 1024, height: 768 }),
+        addEventListener: () => ({ remove: () => {} }),
+    },
+}))
+
+// @react-native-async-storage/async-storage requires the RN module bridge and
+// is pulled in transitively by `~/lib/store`. Substitute a minimal in-memory
+// shim so tests can exercise the Zustand registry without RN.
+vi.mock('@react-native-async-storage/async-storage', () => {
+    const store = new Map<string, string>()
+    const api = {
+        getItem: async (key: string) => store.get(key) ?? null,
+        setItem: async (key: string, value: string) => {
+            store.set(key, value)
+        },
+        removeItem: async (key: string) => {
+            store.delete(key)
+        },
+        clear: async () => {
+            store.clear()
+        },
+        getAllKeys: async () => Array.from(store.keys()),
+        multiGet: async (keys: string[]) => keys.map(k => [k, store.get(k) ?? null]),
+        multiSet: async (pairs: [string, string][]) => {
+            for (const [k, v] of pairs) store.set(k, v)
+        },
+        multiRemove: async (keys: string[]) => {
+            for (const k of keys) store.delete(k)
+        },
+    }
+    return { default: api, ...api }
+})

package/templates/workspace/tinycld.packages.ts

@@ -0,0 +1,75 @@
+import * as fs from 'node:fs'
+import * as path from 'node:path'
+
+// New flat layout: every package (core, app, features) is a direct member dir
+// under the workspace root. core is the member whose package.json name is
+// "@tinycld/core" (it has no manifest.ts). Feature members are dirs with a
+// manifest.ts. Members without a manifest.ts are excluded (this includes the app shell).
+//
+// TINYCLD_WS_ROOT overrides the workspace root for tests that scan a fake tree.
+// It is resolved at call time (not module load) so that tests can set it in
+// beforeEach after the module is already imported.
+const CORE_NAME = '@tinycld/core'
+
+let cached: string[] | null = null
+
+/**
+ * Returns the package names linked into the app, core first then features
+ * sorted by name. Core is the member named "@tinycld/core" (no manifest.ts);
+ * feature members are dirs containing a manifest.ts with a named package.json.
+ * The app shell is excluded. Cached per process; reset with resetPackagesCache().
+ */
+export function getPackages(): string[] {
+    if (cached) return cached
+
+    const wsRoot = process.env.TINYCLD_WS_ROOT
+        ? path.resolve(process.env.TINYCLD_WS_ROOT)
+        : path.resolve(import.meta.dirname)
+
+    let core: string | null = null
+    const features: string[] = []
+
+    if (fs.existsSync(wsRoot)) {
+        for (const entry of fs.readdirSync(wsRoot)) {
+            const dir = path.join(wsRoot, entry)
+            if (!isDir(dir)) continue
+            const pkgJsonPath = path.join(dir, 'package.json')
+            if (!fs.existsSync(pkgJsonPath)) continue
+            let name: unknown
+            try {
+                name = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf8')).name
+            } catch {
+                continue // unreadable package.json
+            }
+            if (typeof name !== 'string' || name.length === 0) continue
+            if (name === CORE_NAME) {
+                core = name
+                continue
+            }
+            if (hasManifest(dir)) features.push(name)
+        }
+    }
+
+    features.sort()
+    cached = core ? [core, ...features] : features
+    return cached
+}
+
+// Test-only: clear the per-process cache so a fresh TINYCLD_WS_ROOT is read.
+export function resetPackagesCache(): void {
+    cached = null
+}
+
+function hasManifest(dir: string): boolean {
+    return (
+        fs.existsSync(path.join(dir, 'manifest.ts')) || fs.existsSync(path.join(dir, 'manifest.js'))
+    )
+}
+
+function isDir(p: string): boolean {
+    try {
+        return fs.statSync(p).isDirectory()
+    } catch {
+        return false
+    }
+}

package/templates/workspace/vitest.config.ts

@@ -0,0 +1,104 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { defineConfig } from 'vitest/config'
+
+// Workspace-root vitest config. Supplies dedup pins, stub aliases, and the
+// react-native/expo/sentry mocks that let the broader core suite run under
+// Node without the Metro/RN runtime.
+const ROOT = import.meta.dirname
+const CORE_DIR = path.join(ROOT, 'core')
+const APP_GENERATED = path.join(ROOT, 'app', 'lib', 'generated')
+
+// Locate a hoisted dependency's dir. In this workspace layout deps hoist to
+// the workspace-root node_modules (all members declare framework deps as
+// peerDependencies only, so the app shell's direct deps live in
+// node_modules/ here at the root). Falls back one level up (CI layouts where
+// the workspace root is nested under another root).
+const pkgDir = (pkg: string): string => {
+    for (const root of [path.join(ROOT, 'node_modules'), path.join(ROOT, '..', 'node_modules')]) {
+        const candidate = path.join(root, pkg)
+        if (fs.existsSync(candidate)) return candidate
+    }
+    return path.join(ROOT, 'node_modules', pkg)
+}
+
+export default defineConfig({
+    resolve: {
+        alias: [
+            // --- dedup pins (Vite SSR resolver differs from Metro; keep until
+            //     a test proves the workspace dedupes these on its own) ---
+            { find: /^react$/, replacement: path.join(pkgDir('react'), 'index.js') },
+            {
+                find: /^react\/jsx-runtime$/,
+                replacement: path.join(pkgDir('react'), 'jsx-runtime.js'),
+            },
+            {
+                find: /^react\/jsx-dev-runtime$/,
+                replacement: path.join(pkgDir('react'), 'jsx-dev-runtime.js'),
+            },
+            // yjs/y-protocols use instanceof checks; a duplicate copy reached
+            // through a member symlink breaks nested Y.Map.set. Pin to the
+            // single install.
+            { find: /^yjs$/, replacement: pkgDir('yjs') },
+            { find: /^y-protocols\/(.+)$/, replacement: `${pkgDir('y-protocols')}/$1` },
+            // hyperformula's ESM build has broken relative imports under Vite
+            // SSR; pin to the self-consistent commonjs entry.
+            {
+                find: /^hyperformula$/,
+                replacement: path.join(pkgDir('hyperformula'), 'commonjs/index.js'),
+            },
+            // --- @tinycld/core path remaps. Unlike Metro, Vite's exports-map
+            //     resolution does NOT do directory-index fallback, so
+            //     `@tinycld/core/lib/notify` (a dir → lib/notify/index.ts) fails
+            //     to load through the exports wildcard. Remap straight to the
+            //     core source path, which Vite resolves with its own extension
+            //     + index probing.
+            {
+                find: /^@tinycld\/core$/,
+                replacement: path.join(CORE_DIR, 'index.ts'),
+            },
+            {
+                find: /^@tinycld\/core\/(.+)$/,
+                replacement: `${CORE_DIR}/$1`,
+            },
+            // --- @tinycld/app-generated/* build-time contract (written to
+            //     app/lib/generated/ by the generator; Vitest doesn't read
+            //     tsconfig paths) ---
+            {
+                find: /^@tinycld\/app-generated\/(.+)$/,
+                replacement: `${APP_GENERATED}/$1`,
+            },
+            // --- test doubles ---
+            // expo-clipboard transitively pulls in expo-modules-core, whose
+            // module-load-time side effects don't survive a bare Node test env.
+            {
+                find: /^expo-clipboard$/,
+                replacement: path.join(ROOT, 'tests/expo-clipboard-stub.ts'),
+            },
+            // expo-router's CJS entry does `require("./global")` at module top,
+            // which Node can't resolve when reached through a member symlink.
+            {
+                find: /^expo-router$/,
+                replacement: path.join(ROOT, 'tests/expo-router-stub.ts'),
+            },
+            // lucide-react-native pulls in react-native-svg (TS source, not
+            // transformed in node_modules under Vitest); a CJS Proxy stub
+            // yields a harmless component for any named icon import.
+            {
+                find: /^lucide-react-native$/,
+                replacement: path.join(ROOT, 'tests/lucide-react-native-stub.cjs'),
+            },
+        ],
+    },
+    test: {
+        environment: 'node',
+        include: [
+            'tests/**/*.test.{ts,tsx}',
+            'core/**/__tests__/**/*.test.{ts,tsx}',
+            'core/**/*.test.{ts,tsx}',
+            'app/scripts/**/__tests__/**/*.test.{ts,tsx}',
+            'package-scripts/tests/**/*.test.{ts,tsx}',
+        ],
+        setupFiles: ['tests/unit-setup.ts'],
+    },
+})