@tailorkit/app 0.1.0-beta.13 → 0.1.0-beta.16

package/dist/builder.js

@@ -1,12 +1,12 @@
 import {
   loadTailorKitConfig
-} from "./chunk-EKCUETAV.js";
-import "./chunk-ZFYKVXDO.js";
+} from "./chunk-DEU6RITM.js";
+import "./chunk-GVB2PAK7.js";
 
 // src/builder/index.ts
-import path from "path";
-import { createRequire } from "module";
-import { readFile, writeFile } from "fs/promises";
+import path6 from "path";
+import { createRequire as createRequire2 } from "module";
+import { readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
 
 // ../asset-delivery/dist/logo-validation.mjs
 var maxLogoBytes = 262144;
@@ -96,45 +96,370 @@ var assertSupportedPreactVersion = (version) => {
   return check;
 };
 
+// src/builder/server.ts
+import { mkdir, mkdtemp as mkdtemp2, writeFile, cp, rm as rm2 } from "fs/promises";
+import path4 from "path";
+import { build } from "vite";
+
+// src/builder/migrations.ts
+import { createHash } from "crypto";
+import { readdir, readFile } from "fs/promises";
+import path from "path";
+async function readAppMigrations(directory, optional = false) {
+  const entries = await readdir(directory, { withFileTypes: true }).catch((error) => {
+    if (error.code === "ENOENT") {
+      if (optional) return [];
+      throw new Error(
+        `App migrations directory is missing: ${directory}. Run tailorkit db generate and commit migrations before building.`,
+        { cause: error }
+      );
+    }
+    throw error;
+  });
+  const migrations = [];
+  const files = [directory];
+  const names = entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+  for (const name of names) {
+    if (!/^\d{14}_[\w-]+$/u.test(name)) {
+      throw new Error(`Unsupported app migration folder: ${name}. Use Drizzle Kit v1 migrations.`);
+    }
+    const file = path.join(directory, name, "migration.sql");
+    const sql = await readFile(file, "utf8");
+    const statements = sql.split("--> statement-breakpoint").map((part) => part.trim()).filter(Boolean);
+    if (!statements.length) throw new Error(`App migration is empty: ${name}`);
+    migrations.push({
+      id: name,
+      hash: createHash("sha256").update(sql).digest("hex"),
+      statements
+    });
+    files.push(file);
+  }
+  return { migrations, files };
+}
+
+// src/server/bundle.ts
+var runtimeManifest = {
+  apiVersion: 1,
+  requires: ["database", "actions"]
+};
+
+// src/builder/schema-check.ts
+import { execFile } from "child_process";
+import { access as access2, mkdtemp, readFile as readFile2, readdir as readdir2, rm } from "fs/promises";
+import { tmpdir } from "os";
+import path3 from "path";
+import { promisify } from "util";
+
+// src/builder/drizzle.ts
+import { access } from "fs/promises";
+import { createRequire } from "module";
+import path2 from "path";
+async function drizzleGenerateArguments(root, output, name) {
+  const require2 = createRequire(path2.join(root, "package.json"));
+  for (const directory of require2.resolve.paths("drizzle-kit") ?? []) {
+    const cli = path2.join(directory, "drizzle-kit/bin.cjs");
+    if (await access(cli).then(() => true).catch(() => false)) {
+      return [
+        "--preserve-symlinks-main",
+        cli,
+        "generate",
+        "--dialect",
+        "sqlite",
+        "--schema",
+        path2.join(root, "src/schema.ts"),
+        "--out",
+        output,
+        ...name === void 0 ? [] : ["--name", name]
+      ];
+    }
+  }
+  throw new Error(
+    "Install drizzle-kit and drizzle-orm as dev dependencies, then run tailorkit db generate."
+  );
+}
+
+// src/builder/schema-check.ts
+var run = promisify(execFile);
+async function snapshot(directory) {
+  const entries = await readdir2(directory, { withFileTypes: true }).catch((error) => {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  });
+  const latest = entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort().at(-1);
+  if (!latest) return;
+  const filename = path3.join(directory, latest, "snapshot.json");
+  const value = JSON.parse(await readFile2(filename, "utf8"));
+  if (value.version !== "7" || value.dialect !== "sqlite" || !Array.isArray(value.ddl)) {
+    throw new Error(
+      `Unsupported app schema snapshot: ${filename}. Use Drizzle Kit v1 SQLite migrations.`
+    );
+  }
+  return value;
+}
+function canonical(value) {
+  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+  if (value && typeof value === "object") {
+    return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => `${JSON.stringify(key)}:${canonical(item)}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+async function checkAppSchema(root, migrationsDirectory) {
+  const schema = path3.join(root, "src/schema.ts");
+  try {
+    await access2(schema);
+  } catch (error) {
+    if (error.code === "ENOENT") return;
+    throw error;
+  }
+  const temporary = await mkdtemp(path3.join(tmpdir(), "tailorkit-schema-check-"));
+  try {
+    const { stdout } = await run(
+      process.execPath,
+      await drizzleGenerateArguments(root, temporary),
+      {
+        cwd: root,
+        timeout: 3e4,
+        maxBuffer: 1024 * 1024,
+        env: { ...process.env, CI: "true" }
+      }
+    ).catch((error) => {
+      throw new Error(
+        "Could not check the app database schema with Drizzle Kit. Check src/schema.ts and your drizzle-kit/drizzle-orm dependencies.",
+        { cause: error }
+      );
+    });
+    const current = await snapshot(temporary);
+    if (!current && !stdout.includes("No schema changes")) {
+      throw new Error(
+        "Drizzle Kit did not produce a schema snapshot. Check src/schema.ts and run tailorkit db generate."
+      );
+    }
+    const saved = await snapshot(migrationsDirectory);
+    const expected = (current?.ddl ?? []).map(canonical).sort();
+    const actual = (saved?.ddl ?? []).map(canonical).sort();
+    if (canonical(expected) !== canonical(actual)) {
+      throw new Error(
+        `App database migrations are missing or out of sync with src/schema.ts. Run tailorkit db generate, commit the generated files in ${path3.relative(root, migrationsDirectory)}, then build again.`
+      );
+    }
+  } finally {
+    await rm(temporary, { recursive: true, force: true });
+  }
+}
+
+// src/builder/server.ts
+async function buildServer(loaded, watch = false, buildOutDir) {
+  const config = loaded.config.server;
+  if (!config) {
+    return;
+  }
+  const output = buildOutDir ?? path4.resolve(loaded.root, loaded.config.build?.outDir ?? ".tailorkit");
+  const directory = path4.join(output, "server");
+  const migrationsDirectory = path4.resolve(loaded.root, config.migrations ?? "./migrations");
+  const migrationsOutput = path4.join(output, "migrations");
+  const temporaryRoot = path4.join(output, "tmp");
+  for (const destination of [
+    directory,
+    path4.join(output, "client"),
+    migrationsOutput,
+    temporaryRoot
+  ]) {
+    if (overlaps(migrationsDirectory, destination)) {
+      throw new Error("App build output must not overlap migration source");
+    }
+  }
+  await rm2(directory, { recursive: true, force: true });
+  await mkdir(directory, { recursive: true });
+  await mkdir(temporaryRoot, { recursive: true });
+  const temporary = await mkdtemp2(path4.join(temporaryRoot, "server-"));
+  const entry = path4.join(temporary, "entry.mjs");
+  let watching = false;
+  try {
+    await writeFile(
+      entry,
+      `export { default } from ${JSON.stringify(path4.resolve(loaded.root, config.entry ?? "src/server.ts"))};
+export { default as migrations } from "tailorkit:migrations";
+export const runtimeManifest = ${JSON.stringify(runtimeManifest)};
+`
+    );
+    const result = await build({
+      root: loaded.root,
+      configFile: false,
+      plugins: [
+        {
+          name: "tailorkit-app-migrations",
+          closeWatcher: () => rm2(temporary, { recursive: true, force: true }),
+          resolveId(id) {
+            if (id === "tailorkit:migrations") {
+              return "\0tailorkit:migrations";
+            }
+          },
+          async load(id) {
+            if (id !== "\0tailorkit:migrations") {
+              return;
+            }
+            const { migrations, files } = await readAppMigrations(
+              migrationsDirectory,
+              config.migrations === void 0
+            );
+            await checkAppSchema(loaded.root, migrationsDirectory);
+            this.addWatchFile(path4.join(loaded.root, "src/schema.ts"));
+            for (const file of files) {
+              this.addWatchFile(file);
+            }
+            await rm2(migrationsOutput, { recursive: true, force: true });
+            await mkdir(migrationsOutput, { recursive: true });
+            await cp(migrationsDirectory, migrationsOutput, { recursive: true }).catch(
+              (error) => {
+                if (config.migrations === void 0 && error.code === "ENOENT") {
+                  return;
+                }
+                throw error;
+              }
+            );
+            return `export default ${JSON.stringify(migrations)};`;
+          }
+        }
+      ],
+      build: {
+        ssr: entry,
+        outDir: directory,
+        emptyOutDir: false,
+        target: "es2022",
+        watch: watch ? {} : null,
+        rollupOptions: {
+          external: [],
+          output: { entryFileNames: "server.js", inlineDynamicImports: true }
+        }
+      },
+      ssr: { noExternal: true }
+    });
+    watching = watch;
+    return result;
+  } finally {
+    if (!watching) {
+      await rm2(temporary, { recursive: true, force: true });
+    }
+  }
+}
+function overlaps(source, destination) {
+  const contains = (parent, child) => {
+    const relative = path4.relative(parent, child);
+    return relative === "" || !path4.isAbsolute(relative) && relative !== ".." && !relative.startsWith(`..${path4.sep}`);
+  };
+  return contains(source, destination) || contains(destination, source);
+}
+
 // src/builder/upload-manifest.ts
 import { z } from "zod";
 var tailorkitUploadManifestSchema = z.object({
   assets: z.object({
-    client: z.literal("client.js"),
+    client: z.literal("client/client.js"),
+    server: z.literal("server/server.js").optional(),
     logos: z.object({
-      dark: z.string().regex(/^logo-dark\.(?:png|svg|webp)$/u).optional(),
-      light: z.string().regex(/^logo-light\.(?:png|svg|webp)$/u).optional()
+      dark: z.string().regex(/^client\/logo-dark\.(?:png|svg|webp)$/u).optional(),
+      light: z.string().regex(/^client\/logo-light\.(?:png|svg|webp)$/u).optional()
     }).optional()
   }),
   version: z.literal(1)
 });
-var createTailorKitUploadManifest = (logos) => tailorkitUploadManifestSchema.parse({
+var createTailorKitUploadManifest = (logos, server = false) => tailorkitUploadManifestSchema.parse({
   assets: {
-    client: "client.js",
+    client: "client/client.js",
+    ...server ? { server: "server/server.js" } : {},
     ...logos && Object.keys(logos).length > 0 ? { logos } : {}
   },
   version: 1
 });
 
+// src/builder/generate-migrations.ts
+import { spawn } from "child_process";
+import { access as access3 } from "fs/promises";
+import path5 from "path";
+async function generateAppMigrations(options = {}) {
+  const loaded = await loadTailorKitConfig(options.configPath, options.cwd);
+  if (!loaded.config.server) {
+    throw new Error(
+      "Enable server: {} in tailorkit.config.ts before generating database migrations."
+    );
+  }
+  await access3(path5.join(loaded.root, "src/schema.ts")).catch((error) => {
+    throw new Error(
+      "Define the app database schema in src/schema.ts before generating migrations.",
+      { cause: error }
+    );
+  });
+  const directory = path5.resolve(loaded.root, loaded.config.server.migrations ?? "./migrations");
+  const args = await drizzleGenerateArguments(loaded.root, directory, options.name);
+  await new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, args, { cwd: loaded.root, stdio: "inherit" });
+    child.once("error", reject);
+    child.once("close", (code, signal) => {
+      if (code === 0) resolve();
+      else reject(new Error(`Drizzle migration generation failed (${signal ?? code}).`));
+    });
+  });
+  await checkAppSchema(loaded.root, directory);
+  return directory;
+}
+
 // src/builder/index.ts
 var preactPackageJson = "preact/package.json";
 var preactPackageJsonModuleId = "\0tailorkit-preact-package-json";
 var buildApp = async (options = {}) => {
   const loaded = await loadTailorKitConfig(options.configPath, options.cwd);
-  const entry = options.entry ?? loaded.config.client?.entry ?? "./src/client.ts";
+  const entry = path6.resolve(loaded.root, loaded.config.client?.entry ?? "src/client.ts");
+  const serverEntry = path6.resolve(loaded.root, loaded.config.server?.entry ?? "src/server.ts");
   const outDir = options.outDir ?? loaded.config.build?.outDir ?? ".tailorkit";
   const preactVersion = getInstalledPreactVersion(loaded.root);
   assertSupportedPreactVersion(preactVersion);
-  const resolvedOutDir = path.resolve(loaded.root, outDir);
+  const resolvedOutDir = path6.resolve(loaded.root, outDir);
+  const clientOutDir = path6.join(resolvedOutDir, "client");
+  const serverWatcher = await buildServer(loaded, options.watch, resolvedOutDir);
+  const writeBuildExtras = async () => {
+    const logoManifest = {};
+    for (const variant of ["light", "dark"]) {
+      const configuredPath = loaded.config.logos?.[variant];
+      if (!configuredPath) {
+        continue;
+      }
+      const extension = path6.extname(configuredPath).toLowerCase().slice(1);
+      const contentType = { png: "image/png", svg: "image/svg+xml", webp: "image/webp" }[extension];
+      if (!contentType) {
+        throw new Error(`The ${variant} logo must be an SVG, PNG, or WebP file.`);
+      }
+      const content = await readFile3(path6.resolve(loaded.root, configuredPath));
+      validateLogoAsset(content, contentType);
+      const filename = `logo-${variant}.${extension}`;
+      await writeFile2(path6.join(clientOutDir, filename), content);
+      logoManifest[variant] = `client/${filename}`;
+    }
+    await writeFile2(
+      path6.join(resolvedOutDir, "tailorkit-upload.json"),
+      `${JSON.stringify(createTailorKitUploadManifest(logoManifest, Boolean(loaded.config.server)), null, 2)}
+`,
+      "utf-8"
+    );
+  };
+  let firstBuildDone;
+  let firstBuildFailed;
+  const firstBuild = new Promise((resolve, reject) => {
+    firstBuildDone = resolve;
+    firstBuildFailed = reject;
+  });
+  if (!options.watch) {
+    void firstBuild.catch(() => {
+    });
+  }
   const result = await viteBuild({
     build: {
       emptyOutDir: true,
       lib: {
-        entry: path.resolve(loaded.root, entry),
+        entry,
         fileName: "client",
         formats: ["es"]
       },
-      outDir: resolvedOutDir,
+      outDir: clientOutDir,
       watch: options.watch ? {} : null,
       minify: "oxc",
       rollupOptions: {
@@ -151,7 +476,42 @@ var buildApp = async (options = {}) => {
     },
     configFile: false,
     mode: options.mode,
+    oxc: { jsx: { importSource: "preact" } },
     plugins: [
+      {
+        name: "tailorkit-browser-server-boundary",
+        enforce: "pre",
+        async resolveId(id, importer) {
+          if (/^(?:@tailorkit\/app\/server$|tailorkit\/(?:server|app\/server)$|effect(?:\/|$))/u.test(
+            id
+          ) || importer && path6.resolve(path6.dirname(importer), id) === serverEntry) {
+            throw new Error(
+              "App server implementations cannot be imported into a browser bundle. Import api from #tailorkit and server types with import type."
+            );
+          }
+          if (importer) {
+            const resolved = await this.resolve(id, importer, { skipSelf: true });
+            if (resolved?.id.split("?")[0] === serverEntry) {
+              throw new Error(
+                "App server implementations cannot be imported into a browser bundle. Import api from #tailorkit and server types with import type."
+              );
+            }
+          }
+          return null;
+        }
+      },
+      {
+        name: "tailorkit-preview-build-ready",
+        async writeBundle() {
+          try {
+            await writeBuildExtras();
+            firstBuildDone?.();
+          } catch (error) {
+            firstBuildFailed?.(error instanceof Error ? error : new Error(String(error)));
+            throw error;
+          }
+        }
+      },
       {
         name: "tailorkit-preact-package-json",
         enforce: "pre",
@@ -171,38 +531,46 @@ var buildApp = async (options = {}) => {
       }
     ],
     root: loaded.root
+  }).catch(async (error) => {
+    if (serverWatcher && typeof serverWatcher === "object" && "close" in serverWatcher) {
+      await serverWatcher.close();
+    }
+    throw error;
   });
-  const logoManifest = {};
-  for (const variant of ["light", "dark"]) {
-    const configuredPath = loaded.config.logos?.[variant];
-    if (!configuredPath) {
-      continue;
+  if (options.watch) {
+    if (result && typeof result === "object" && "on" in result) {
+      result.on("event", (event) => {
+        if (event.code === "ERROR") {
+          firstBuildFailed?.(event.error ?? new Error("Initial app build failed."));
+        }
+      });
     }
-    const extension = path.extname(configuredPath).toLowerCase().slice(1);
-    const contentType = {
-      png: "image/png",
-      svg: "image/svg+xml",
-      webp: "image/webp"
-    }[extension];
-    if (!contentType) {
-      throw new Error(`The ${variant} logo must be an SVG, PNG, or WebP file.`);
+    try {
+      await firstBuild;
+    } catch (error) {
+      if (result && typeof result === "object" && "close" in result) {
+        await result.close();
+      }
+      if (serverWatcher && typeof serverWatcher === "object" && "close" in serverWatcher) {
+        await serverWatcher.close();
+      }
+      throw error;
     }
-    const content = await readFile(path.resolve(loaded.root, configuredPath));
-    validateLogoAsset(content, contentType);
-    const filename = `logo-${variant}.${extension}`;
-    await writeFile(path.join(resolvedOutDir, filename), content);
-    logoManifest[variant] = filename;
-  }
-  await writeFile(
-    path.join(resolvedOutDir, "tailorkit-upload.json"),
-    `${JSON.stringify(createTailorKitUploadManifest(logoManifest), null, 2)}
-`,
-    "utf-8"
-  );
+  }
+  if (options.watch && result && typeof result === "object" && "close" in result && serverWatcher && typeof serverWatcher === "object" && "close" in serverWatcher) {
+    const clientWatcher = result;
+    return {
+      on: clientWatcher.on.bind(clientWatcher),
+      async close() {
+        await clientWatcher.close();
+        await serverWatcher.close();
+      }
+    };
+  }
   return result;
 };
 function getInstalledPreactVersion(root) {
-  const require2 = createRequire(path.join(root, "package.json"));
+  const require2 = createRequire2(path6.join(root, "package.json"));
   try {
     const packageJsonPath = require2.resolve("preact/package.json");
     const packageJson = require2(packageJsonPath);
@@ -220,5 +588,6 @@ function getInstalledPreactVersion(root) {
 export {
   buildApp,
   createTailorKitUploadManifest,
+  generateAppMigrations,
   tailorkitUploadManifestSchema
 };