create-monolayer-app 0.3.0 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-monolayer-app",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "CLI to scaffold a new monolayer application",
   "type": "module",
   "bin": {

package/template/_gitignore

@@ -1,12 +1,17 @@
 .DS_Store
 
 .env
-/node_modules/
 
-# React Router
+node_modules/
 
-/.react-router/
-/build/
+# React Router
+.react-router/
+build/
 
 .pglite_development/
 .pglite_test/
+
+.config/kysely.config.js
+.config/kysely.config.js.map
+
+.emulator/

package/template/package.json

@@ -16,7 +16,8 @@
     "postmigrate:down": "npm run db:create-types",
     "migrate:list": "kysely migrate:list",
     "migrate:make": "tsx vendor/kysely-dsql/generator/create-migration.ts",
-    "db:create-types": "tsx vendor/kysely-dsql/generator/generate-types-from-pglite.ts"
+    "db:create-types": "tsx vendor/kysely-dsql/generator/generate-types-from-pglite.ts",
+    "package-app": "node vendor/package-app/package-app.mjs"
   },
   "dependencies": {
     "@aws-sdk/dsql-signer": "^3.1126.0",

package/template/vendor/package-app/package-app.mjs

@@ -0,0 +1,116 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { pathToFileURL } from "node:url";
+
+const DEFAULT_OUTPUT_DIR = "build";
+const DEFAULT_GITIGNORE = ".gitignore";
+const DEFAULT_EXCLUDES = [".git", "build"];
+
+/**
+ * Resolves the package name from package.json in the target directory.
+ *
+ * @param {string} cwd - The project root directory.
+ * @returns {string} Sanitized package name or fallback "app".
+ */
+function getPackageName(cwd) {
+  const packageJsonPath = path.resolve(cwd, "package.json");
+  if (existsSync(packageJsonPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+      // oxlint-disable-next-line anti-slop/no-runtime-typeof
+      if (typeof pkg.name === "string" && pkg.name.trim()) {
+        return pkg.name.trim().replace(/^@/u, "").replaceAll("/", "-");
+      }
+    } catch {
+      // Ignore parse errors and use fallback
+    }
+  }
+  return "app";
+}
+
+/**
+ * Packages the current application directory into a timestamped tar.gz archive:
+ * `<package-name>-<timestamp>.tar.gz`
+ * Cleans and recreates the output directory before packaging.
+ *
+ * @param {Object} [options] - Configuration options for packaging.
+ * @param {string} [options.cwd] - The project root directory. Defaults to `process.cwd()`.
+ * @param {string} [options.outputDirectory] - Output directory relative to `cwd`. Defaults to `"build"`.
+ * @param {string} [options.packageName] - Custom package name override. Defaults to name from `package.json`.
+ * @param {number} [options.timestamp] - Custom timestamp for the archive filename. Defaults to `Date.now()`.
+ * @param {string[]} [options.excludes] - Patterns to exclude from the archive.
+ * @param {string} [options.gitignorePath] - Gitignore file path relative to `cwd`. Defaults to `".gitignore"`.
+ * @returns {{ archiveName: string, relativePath: string, absolutePath: string, packageName: string }} Details of the generated archive.
+ */
+export function packageApp(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const outputDirectory = options.outputDirectory ?? DEFAULT_OUTPUT_DIR;
+  const targetDir = path.resolve(cwd, outputDirectory);
+
+  // Clean and recreate the output directory
+  if (existsSync(targetDir)) {
+    rmSync(targetDir, { recursive: true, force: true });
+  }
+  mkdirSync(targetDir, { recursive: true });
+
+  const packageName = options.packageName ?? getPackageName(cwd);
+  const timestamp = options.timestamp ?? Date.now();
+  const archiveName = `${timestamp}.tar.gz`;
+  const relativePath = path.posix.join(outputDirectory, archiveName);
+  const absolutePath = path.resolve(cwd, relativePath);
+
+  const gitignoreFile = options.gitignorePath ?? DEFAULT_GITIGNORE;
+  const excludes = options.excludes ?? DEFAULT_EXCLUDES;
+
+  const tarArgs = ["-czf", relativePath];
+
+  const fullGitignorePath = path.resolve(cwd, gitignoreFile);
+  if (existsSync(fullGitignorePath)) {
+    tarArgs.push(`--exclude-from=${gitignoreFile}`);
+  }
+
+  for (const exclude of excludes) {
+    tarArgs.push(`--exclude=${exclude}`);
+  }
+
+  tarArgs.push(".");
+
+  const result = spawnSync("tar", tarArgs, {
+    cwd,
+    stdio: "inherit",
+  });
+
+  if (result.error) {
+    throw result.error;
+  }
+
+  if (result.status !== 0) {
+    throw new Error(`tar process exited with status ${result.status}`);
+  }
+
+  return {
+    archiveName,
+    relativePath,
+    absolutePath,
+    packageName,
+  };
+}
+
+const [, entryPath] = process.argv;
+if (
+  entryPath &&
+  import.meta.url === pathToFileURL(path.resolve(entryPath)).href
+) {
+  try {
+    const result = packageApp();
+    console.log(`Successfully packaged application to ${result.relativePath}`);
+  } catch (error) {
+    console.error(
+      "Failed to package application:",
+      error instanceof Error ? error.message : error
+    );
+    process.exitCode = 1;
+  }
+}