create-nanoka-app 1.0.0

package/README.md

@@ -0,0 +1,23 @@
+# create-nanoka-app
+
+Create a new Nanoka (Hono + Drizzle + D1) project in seconds.
+
+## Usage
+
+```bash
+pnpm create nanoka-app my-app
+# or
+npx create-nanoka-app my-app
+```
+
+## Getting started
+
+After scaffolding:
+
+```bash
+cd my-app
+pnpm install
+pnpm exec nanoka generate
+pnpm exec drizzle-kit generate
+pnpm dev
+```

package/dist/index.js

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { cp, mkdir, readdir, readFile, writeFile } from "fs/promises";
+import { createRequire } from "module";
+import { basename, dirname, extname, join, resolve } from "path";
+import { fileURLToPath } from "url";
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  if (args.includes("--help") || args.includes("-h")) {
+    return { kind: "help" };
+  }
+  if (args.includes("--version") || args.includes("-v")) {
+    return { kind: "version" };
+  }
+  let targetDir = "";
+  let template = "default";
+  let force = false;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--template") {
+      const next = args[i + 1];
+      if (next !== "default") {
+        throw new Error(`Unknown template: "${next ?? ""}". Available templates: default`);
+      }
+      template = next;
+      i++;
+    } else if (arg === "--force") {
+      force = true;
+    } else if (!arg.startsWith("-")) {
+      targetDir = arg;
+    }
+  }
+  if (!targetDir) {
+    throw new Error("Please specify a project directory: create-nanoka-app <dir>");
+  }
+  return { targetDir, template, force };
+}
+async function copyTemplate(srcDir, destDir, vars) {
+  await mkdir(destDir, { recursive: true });
+  const entries = await readdir(srcDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = join(srcDir, entry.name);
+    const isTmpl = extname(entry.name) === ".tmpl";
+    const destName = isTmpl ? basename(entry.name, ".tmpl") : entry.name;
+    const destPath = join(destDir, destName);
+    if (entry.isDirectory()) {
+      await copyTemplate(srcPath, destPath, vars);
+    } else if (isTmpl) {
+      let content = await readFile(srcPath, "utf-8");
+      for (const [key, value] of Object.entries(vars)) {
+        content = content.replaceAll(`{{${key}}}`, value);
+      }
+      await writeFile(destPath, content, "utf-8");
+    } else {
+      await cp(srcPath, destPath);
+    }
+  }
+}
+async function scaffold(opts) {
+  const targetDir = resolve(process.cwd(), opts.targetDir);
+  const packageName = basename(targetDir);
+  const packageNameRegex = /^[a-z0-9][a-z0-9\-_.]*$/;
+  if (!packageNameRegex.test(packageName)) {
+    throw new Error(
+      `Invalid package name: '${packageName}'. Must match /^[a-z0-9][a-z0-9-_.]*$/ (lowercase letters, digits, hyphens, dots, underscores).`
+    );
+  }
+  try {
+    const entries = await readdir(targetDir);
+    if (entries.length > 0 && !opts.force) {
+      throw new Error(
+        `Directory "${opts.targetDir}" already exists and is not empty. Use --force to overwrite.`
+      );
+    }
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      throw err;
+    }
+  }
+  const selfDir = dirname(fileURLToPath(import.meta.url));
+  const templateDir = join(selfDir, "../templates", opts.template);
+  const require2 = createRequire(import.meta.url);
+  const { version } = require2("../package.json");
+  const vars = {
+    packageName,
+    nanokaVersion: version
+  };
+  await copyTemplate(templateDir, targetDir, vars);
+  console.log(`
+Created "${packageName}" at ${targetDir}`);
+  console.log("\nNext steps:");
+  console.log(`  cd ${opts.targetDir}`);
+  console.log("  pnpm install");
+  console.log("  pnpm exec nanoka generate");
+  console.log("  pnpm exec drizzle-kit generate");
+  console.log("  pnpm dev");
+}
+async function main() {
+  const result = parseArgs(process.argv);
+  if ("kind" in result) {
+    if (result.kind === "help") {
+      console.log("Usage: create-nanoka-app <dir> [--template default] [--force]");
+      console.log("\nOptions:");
+      console.log("  --template <name>  Template to use (default: default)");
+      console.log("  --force            Overwrite existing directory");
+      console.log("  --help, -h         Show this help message");
+      console.log("  --version, -v      Show version number");
+      return;
+    }
+    if (result.kind === "version") {
+      const require2 = createRequire(import.meta.url);
+      const { version } = require2("../package.json");
+      console.log(version);
+      return;
+    }
+  }
+  await scaffold(result);
+}
+if (process.argv[1] != null && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  main().catch((err) => {
+    console.error(err.message ?? err);
+    process.exit(1);
+  });
+}
+export {
+  copyTemplate,
+  parseArgs,
+  scaffold
+};

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "create-nanoka-app",
+  "version": "1.0.0",
+  "description": "Create a new Nanoka (Hono + D1) project",
+  "type": "module",
+  "bin": {
+    "create-nanoka-app": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "templates",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup && node ./scripts/prepend-shebang.mjs",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "prepublishOnly": "pnpm build && pnpm typecheck && pnpm test"
+  },
+  "devDependencies": {
+    "@types/node": "^25.6.0",
+    "tsup": "^8.3.0",
+    "typescript": "^5.6.0",
+    "vitest": "^2.1.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nanokajs/nanoka.git"
+  },
+  "license": "MIT"
+}

package/templates/default/README.md

@@ -0,0 +1,12 @@
+# My Nanoka App
+
+A Hono + Drizzle + D1 project scaffolded with `create-nanoka-app`.
+
+## Quickstart
+
+```bash
+pnpm install
+pnpm exec nanoka generate
+pnpm exec drizzle-kit generate
+pnpm dev
+```

package/templates/default/drizzle.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from 'drizzle-kit'
+
+export default defineConfig({
+  schema: './drizzle/schema.ts',
+  out: './drizzle/migrations',
+  dialect: 'sqlite',
+  driver: 'd1-http',
+})

package/templates/default/nanoka.config.ts

@@ -0,0 +1,12 @@
+import { defineConfig } from '@nanokajs/core/config'
+import { userFields, userTableName } from './src/models/user'
+
+export default defineConfig({
+  models: [
+    {
+      name: userTableName,
+      fields: userFields,
+    },
+  ],
+  output: './drizzle/schema.ts',
+})

package/templates/default/package.json.tmpl

@@ -0,0 +1,22 @@
+{
+  "name": "{{packageName}}",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "wrangler dev",
+    "db:generate": "drizzle-kit generate",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@nanokajs/core": "{{nanokaVersion}}",
+    "hono": "^4.0.0",
+    "drizzle-orm": "^0.45.2",
+    "zod": "^3.23.0 || ^4.0.0"
+  },
+  "devDependencies": {
+    "@cloudflare/workers-types": "^4.20240925.0",
+    "drizzle-kit": "^0.28.0",
+    "typescript": "^5.6.0",
+    "wrangler": "^3.80.0"
+  }
+}

package/templates/default/src/index.ts

@@ -0,0 +1,38 @@
+import { d1Adapter, nanoka } from '@nanokajs/core'
+import { z } from 'zod'
+import { userFields, userTableName } from './models/user'
+
+export interface Env {
+  DB: D1Database
+}
+
+export default {
+  async fetch(req: Request, env: Env, ctx: ExecutionContext) {
+    const app = nanoka<{ Bindings: Env }>(d1Adapter(env.DB))
+    const User = app.model(userTableName, userFields)
+
+    app.post(
+      '/users',
+      User.validator('json', { omit: ['id', 'passwordHash', 'createdAt'] }),
+      async (c) => {
+        const body = c.req.valid('json')
+        const created = await User.create({
+          ...body,
+          id: crypto.randomUUID(),
+          passwordHash: 'hashed_value_here',
+          createdAt: new Date(),
+        })
+        const user = User.schema({ omit: ['passwordHash'] }).parse(created)
+        return c.json(user, 201)
+      },
+    )
+
+    app.get('/users', async (c) => {
+      const users = await User.findMany({ limit: 20 })
+      const result = z.array(User.schema({ omit: ['passwordHash'] })).parse(users)
+      return c.json(result)
+    })
+
+    return app.fetch(req, env, ctx)
+  },
+}

package/templates/default/src/models/user.ts

@@ -0,0 +1,12 @@
+import { t } from '@nanokajs/core'
+
+export const userTableName = 'users'
+
+export const userFields = {
+  id: t.uuid().primary(),
+  name: t.string().min(1).max(100),
+  email: t.string().email().unique(),
+  passwordHash: t.string().writeOnly(),
+  serverToken: t.string().serverOnly().optional(),
+  createdAt: t.timestamp().default(() => new Date()),
+}

package/templates/default/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ES2022"],
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "verbatimModuleSyntax": true,
+    "isolatedModules": true,
+    "resolveJsonModule": true,
+    "types": ["@cloudflare/workers-types"]
+  },
+  "include": ["src/**/*", "*.config.ts", "nanoka.config.ts"]
+}

package/templates/default/wrangler.toml.tmpl

@@ -0,0 +1,13 @@
+name = "{{packageName}}"
+main = "src/index.ts"
+compatibility_date = "2025-04-01"
+compatibility_flags = ["nodejs_compat"]
+
+[[d1_databases]]
+binding = "DB"
+database_name = "{{packageName}}"
+database_id = "00000000-0000-0000-0000-000000000000"
+migrations_dir = "drizzle/migrations"
+
+[vars]
+ENVIRONMENT = "development"