@jskit-ai/create-app 0.1.2 → 0.1.6

package/templates/base-shell/tests/server/{minimalShell.contract.test.js → minimalShell.validator.test.js}

@@ -9,17 +9,22 @@ const __dirname = path.dirname(__filename);
 const APP_ROOT = path.resolve(__dirname, "../..");
 
 const EXPECTED_RUNTIME_DEPENDENCIES = Object.freeze([
-  "@jskit-ai/app-scripts",
-  "@jskit-ai/server-runtime-core",
+  "@fastify/type-provider-typebox",
+  "@jskit-ai/http-runtime",
+  "@jskit-ai/kernel",
+  "@local/main",
   "fastify",
-  "vue"
+  "vue",
+  "vue-router",
+  "vuetify"
 ]);
 
 const EXPECTED_DEV_DEPENDENCIES = Object.freeze([
   "@jskit-ai/config-eslint",
-  "@jskit-ai/jskit",
+  "@jskit-ai/jskit-cli",
   "@vitejs/plugin-vue",
   "eslint",
+  "unplugin-vue-router",
   "vite",
   "vitest"
 ]);
@@ -29,13 +34,15 @@ const EXPECTED_TOP_LEVEL_ENTRIES = Object.freeze([
   "README.md",
   "app.scripts.config.mjs",
   "bin",
+  "config",
   "eslint.config.mjs",
   "favicon.svg",
-  "gitignore",
   "index.html",
+  "jsconfig.json",
   "package.json",
-  "package.json.ACTUAL_CORRECT",
+  "packages",
   "server.js",
+  "scripts",
   "server",
   "src",
   "tests",
@@ -74,6 +81,20 @@ async function readTopLevelEntries() {
     .filter((name) => !ignored.has(name));
 }
 
+async function listFilesRecursive(directory) {
+  const entries = await readdir(directory, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const absolutePath = path.join(directory, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...(await listFilesRecursive(absolutePath)));
+      continue;
+    }
+    files.push(absolutePath);
+  }
+  return files;
+}
+
 test("minimal shell keeps strict dependency allowlist", async () => {
   const packageJson = await readPackageJson();
   assert.deepEqual(
@@ -94,3 +115,20 @@ test("starter shell keeps a strict top-level footprint", async () => {
 test("legacy app.manifest scaffold is removed from starter shell", async () => {
   await assert.rejects(access(path.join(APP_ROOT, "framework/app.manifest.mjs")), /ENOENT/);
 });
+
+test("local package source avoids brittle deep relative imports", async () => {
+  const packageSourceFiles = await listFilesRecursive(path.join(APP_ROOT, "packages"));
+  const brittleImportPattern = /\bfrom\s+["'](?:\.\.\/){5,}[^"']+["']/;
+
+  for (const filePath of packageSourceFiles) {
+    if (!filePath.endsWith(".js") && !filePath.endsWith(".mjs")) {
+      continue;
+    }
+    const source = await readFile(filePath, "utf8");
+    assert.equal(
+      brittleImportPattern.test(source),
+      false,
+      `Found brittle deep relative import in ${path.relative(APP_ROOT, filePath)}`
+    );
+  }
+});

package/templates/base-shell/tests/server/smoke.test.js

@@ -2,18 +2,15 @@ import assert from "node:assert/strict";
 import test from "node:test";
 import { createServer } from "../../server.js";
 
-test("GET /api/v1/health returns ok payload", async () => {
+test("GET /api/health returns built-in health response", async () => {
   const app = await createServer();
   const response = await app.inject({
     method: "GET",
-    url: "/api/v1/health"
+    url: "/api/health"
   });
 
   assert.equal(response.statusCode, 200);
-  assert.deepEqual(response.json(), {
-    ok: true,
-    app: "__APP_NAME__"
-  });
+  assert.equal(response.json().ok, true);
 
   await app.close();
 });

package/templates/base-shell/vite.config.mjs

@@ -1,9 +1,16 @@
+import { fileURLToPath, URL } from "node:url";
 import { defineConfig } from "vite";
 import vue from "@vitejs/plugin-vue";
-import { toPositiveInt } from "./vite.shared.mjs";
+import VueRouter from "unplugin-vue-router/vite";
+import { createJskitClientBootstrapPlugin } from "@jskit-ai/kernel/client/vite";
+import { loadViteDevProxyEntries, toPositiveInt } from "./vite.shared.mjs";
 
 const devPort = toPositiveInt(process.env.VITE_DEV_PORT, 5173);
 const apiProxyTarget = String(process.env.VITE_API_PROXY_TARGET || "").trim() || "http://localhost:3000";
+const viteModuleProxyEntries = loadViteDevProxyEntries({
+  appRootUrl: import.meta.url,
+  fallbackTarget: apiProxyTarget
+});
 const clientEntry = (() => {
   const normalized = String(process.env.VITE_CLIENT_ENTRY || "").trim();
   if (!normalized) {
@@ -19,12 +26,25 @@ const clientEntry = (() => {
 })();
 
 export default defineConfig({
+  resolve: {
+    preserveSymlinks: true,
+    alias: {
+      "@": fileURLToPath(new URL("./src", import.meta.url))
+    }
+  },
   plugins: [
+    createJskitClientBootstrapPlugin(),
+    VueRouter({
+      routesFolder: "src/pages",
+      dts: "src/typed-router.d.ts"
+    }),
     vue(),
     {
       name: "jskit-client-entry",
       transformIndexHtml(source) {
-        return String(source || "").replace(/\/src\/main\.js/g, clientEntry);
+        return String(source || "")
+          .replace(/\/src\/%VITE_CLIENT_ENTRY%/g, clientEntry)
+          .replace(/\/src\/main\.js/g, clientEntry);
       }
     }
   ],
@@ -37,7 +57,8 @@ export default defineConfig({
       "/api": {
         target: apiProxyTarget,
         changeOrigin: true
-      }
+      },
+      ...viteModuleProxyEntries
     }
   }
 });

package/templates/base-shell/vite.shared.mjs

@@ -1,3 +1,9 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const VITE_DEV_PROXY_CONFIG_RELATIVE_PATH = ".jskit/vite.dev.proxy.json";
+
 function toPositiveInt(value, fallback) {
   const parsed = Number.parseInt(String(value || "").trim(), 10);
   if (Number.isInteger(parsed) && parsed > 0) {
@@ -6,4 +12,48 @@ function toPositiveInt(value, fallback) {
   return fallback;
 }
 
-export { toPositiveInt };
+function loadViteDevProxyEntries({ appRootUrl = import.meta.url, fallbackTarget = "" } = {}) {
+  const appRootPath = fileURLToPath(new URL(".", appRootUrl));
+  const absoluteConfigPath = path.join(appRootPath, VITE_DEV_PROXY_CONFIG_RELATIVE_PATH);
+  if (!existsSync(absoluteConfigPath)) {
+    return Object.freeze({});
+  }
+
+  let source = {};
+  try {
+    source = JSON.parse(readFileSync(absoluteConfigPath, "utf8"));
+  } catch {
+    return Object.freeze({});
+  }
+
+  const entries = Array.isArray(source?.entries) ? source.entries : [];
+  const proxy = {};
+  for (const entry of entries) {
+    const record = entry && typeof entry === "object" && !Array.isArray(entry) ? entry : {};
+    const routePath = String(record.path || "").trim();
+    if (!routePath || !routePath.startsWith("/")) {
+      continue;
+    }
+
+    const target = String(record.target || "").trim() || String(fallbackTarget || "").trim();
+    if (!target) {
+      continue;
+    }
+
+    const proxyConfig = {
+      target
+    };
+    if (Object.hasOwn(record, "changeOrigin")) {
+      proxyConfig.changeOrigin = record.changeOrigin === true;
+    }
+    if (Object.hasOwn(record, "ws")) {
+      proxyConfig.ws = record.ws === true;
+    }
+
+    proxy[routePath] = proxyConfig;
+  }
+
+  return Object.freeze(proxy);
+}
+
+export { toPositiveInt, loadViteDevProxyEntries };

package/README.md

@@ -1,24 +0,0 @@
-# @jskit-ai/create-app
-
-Scaffold a minimal JSKIT app shell from in-repo templates.
-
-## Usage
-
-```bash
-jskit-create-app my-app
-```
-
-```bash
-jskit-create-app --interactive
-```
-
-## Options
-
-- `--template <name>` template name under `templates/` (default `base-shell`)
-- `--title <text>` override the generated app title placeholder
-- `--target <path>` output directory (default `./<app-name>`)
-- `--initial-bundles <preset>` optional framework preset: `none`, `db`, or `db-auth`
-- `--db-provider <provider>` provider for `db` presets: `mysql` or `postgres`
-- `--force` allow writes into non-empty target directories
-- `--dry-run` preview writes only
-- `--interactive` prompt for app values

package/templates/base-shell/package.json.ACTUAL_CORRECT

@@ -1,38 +0,0 @@
-{
-  "name": "__APP_NAME__",
-  "version": "0.1.0",
-  "private": true,
-  "type": "module",
-  "description": "Minimal JSKIT base app (Fastify + Vue)",
-  "engines": {
-    "node": "20.x"
-  },
-  "bin": {
-    "jskit": "node_modules/@jskit-ai/jskit/packages/tooling/jskit/bin/jskit.js"
-  },
-  "scripts": {
-    "server": "jskit-app-scripts server",
-    "start": "jskit-app-scripts start",
-    "dev": "jskit-app-scripts dev",
-    "build": "jskit-app-scripts build",
-    "preview": "jskit-app-scripts preview",
-    "lint": "jskit-app-scripts lint",
-    "lint:process-env": "jskit-app-scripts lint:process-env",
-    "test": "jskit-app-scripts test",
-    "test:client": "jskit-app-scripts test:client"
-  },
-  "dependencies": {
-    "@jskit-ai/app-scripts": "0.1.0",
-    "@jskit-ai/server-runtime-core": "file:node_modules/@jskit-ai/jskit/packages/runtime/server-runtime-core",
-    "fastify": "^5.7.4",
-    "vue": "^3.5.13"
-  },
-  "devDependencies": {
-    "@jskit-ai/config-eslint": "0.1.0",
-    "@jskit-ai/jskit": "github:mobily-enterprises/jskit-ai",
-    "@vitejs/plugin-vue": "^5.2.1",
-    "eslint": "^9.39.1",
-    "vite": "^6.1.0",
-    "vitest": "^4.0.18"
-  }
-}