fossyl 0.1.5 → 0.9.0

package/dist/index.js

@@ -1,29 +1,10 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -32,72 +13,1046 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 
 // src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  authWrapper: () => authWrapper,
-  createRouter: () => createRouter
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/router/router.ts
-function createEndpoint(path) {
-  function get(config) {
-    if ("authenticator" in config) {
-      return __spreadProps(__spreadValues({}, config), { type: "authenticated", path, method: "GET" });
-    } else {
-      return __spreadProps(__spreadValues({}, config), { type: "open", path, method: "GET" });
-    }
+var import_node_util = require("util");
+
+// src/commands/create.ts
+var fs2 = __toESM(require("fs"));
+var path2 = __toESM(require("path"));
+var p2 = __toESM(require("@clack/prompts"));
+
+// src/prompts.ts
+var p = __toESM(require("@clack/prompts"));
+async function promptForOptions(projectName) {
+  p.intro("Create Fossyl App");
+  const name = projectName ?? await p.text({
+    message: "Project name:",
+    placeholder: "my-fossyl-api",
+    validate: (v) => !v ? "Required" : void 0
+  });
+  if (p.isCancel(name)) {
+    p.cancel("Operation cancelled.");
+    return null;
   }
-  function put(config) {
-    if ("authenticator" in config) {
-      return __spreadProps(__spreadValues({}, config), { type: "full", path, method: "PUT" });
-    } else {
-      return __spreadProps(__spreadValues({}, config), { type: "validated", path, method: "PUT" });
-    }
+  const server = await p.select({
+    message: "Server adapter:",
+    options: [
+      { value: "express", label: "Express", hint: "recommended" },
+      { value: "byo", label: "Bring Your Own" }
+    ]
+  });
+  if (p.isCancel(server)) {
+    p.cancel("Operation cancelled.");
+    return null;
   }
-  function post(config) {
-    if ("authenticator" in config) {
-      return __spreadProps(__spreadValues({}, config), { type: "full", path, method: "POST" });
-    } else {
-      return __spreadProps(__spreadValues({}, config), { type: "validated", path, method: "POST" });
-    }
+  const validator = await p.select({
+    message: "Validation library:",
+    options: [
+      { value: "zod", label: "Zod", hint: "recommended" },
+      { value: "byo", label: "Bring Your Own" }
+    ]
+  });
+  if (p.isCancel(validator)) {
+    p.cancel("Operation cancelled.");
+    return null;
   }
-  function del(config) {
-    if ("authenticator" in config) {
-      return __spreadProps(__spreadValues({}, config), {
-        type: "authenticated",
-        path,
-        method: "DELETE"
-      });
-    } else {
-      return __spreadProps(__spreadValues({}, config), { type: "open", path, method: "DELETE" });
-    }
+  const database = await p.select({
+    message: "Database adapter:",
+    options: [
+      { value: "kysely", label: "Kysely", hint: "recommended" },
+      { value: "byo", label: "Bring Your Own" }
+    ]
+  });
+  if (p.isCancel(database)) {
+    p.cancel("Operation cancelled.");
+    return null;
   }
-  return {
-    get,
-    post,
-    put,
-    delete: del
+  return { name, server, validator, database };
+}
+
+// src/scaffold.ts
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+
+// src/templates/base.ts
+function generatePackageJson(options) {
+  const dependencies = {
+    "@fossyl/core": "^0.9.0"
   };
+  const devDependencies = {
+    "@types/node": "^22.0.0",
+    tsx: "^4.0.0",
+    typescript: "^5.8.0"
+  };
+  if (options.server === "express") {
+    dependencies["@fossyl/express"] = "^0.9.0";
+    dependencies["express"] = "^4.21.0";
+    devDependencies["@types/express"] = "^4.17.0";
+  }
+  if (options.validator === "zod") {
+    dependencies["@fossyl/zod"] = "^0.9.0";
+    dependencies["zod"] = "^3.24.0";
+  }
+  if (options.database === "kysely") {
+    dependencies["@fossyl/kysely"] = "^0.9.0";
+    dependencies["kysely"] = "^0.27.0";
+    dependencies["pg"] = "^8.13.0";
+    devDependencies["@types/pg"] = "^8.11.0";
+  }
+  const pkg = {
+    name: options.name === "." ? "my-fossyl-api" : options.name,
+    version: "0.1.0",
+    type: "module",
+    scripts: {
+      dev: "tsx watch src/index.ts",
+      build: "tsc",
+      start: "node dist/index.js"
+    },
+    dependencies,
+    devDependencies
+  };
+  return JSON.stringify(pkg, null, 2) + "\n";
+}
+function generateTsConfig() {
+  const config = {
+    compilerOptions: {
+      target: "ES2022",
+      module: "NodeNext",
+      moduleResolution: "NodeNext",
+      esModuleInterop: true,
+      strict: true,
+      skipLibCheck: true,
+      outDir: "./dist",
+      rootDir: "./src",
+      declaration: true
+    },
+    include: ["src/**/*"],
+    exclude: ["node_modules", "dist"]
+  };
+  return JSON.stringify(config, null, 2) + "\n";
+}
+function generateEnvExample(options) {
+  let content = `# Server
+PORT=3000
+`;
+  if (options.database === "kysely") {
+    content += `
+# Database
+DATABASE_URL=postgres://user:password@localhost:5432/mydb
+`;
+  }
+  return content;
+}
+function generateClaudeMd(options) {
+  const adapterDocs = [];
+  if (options.server === "express") {
+    adapterDocs.push("- `@fossyl/express` - Express.js runtime adapter");
+  }
+  if (options.validator === "zod") {
+    adapterDocs.push("- `@fossyl/zod` - Zod validation adapter");
+  }
+  if (options.database === "kysely") {
+    adapterDocs.push("- `@fossyl/kysely` - Kysely database adapter");
+  }
+  const byoNotes = [];
+  if (options.server === "byo") {
+    byoNotes.push(`
+### Server (BYO)
+You need to implement your own server adapter. See \`src/server.ts\` for the placeholder.
+Check the @fossyl/express source for reference: https://github.com/YoyoSaur/fossyl/tree/main/packages/express`);
+  }
+  if (options.validator === "byo") {
+    byoNotes.push(`
+### Validator (BYO)
+You need to implement your own validators. See \`src/features/ping/validators/ping.validators.ts\` for the placeholder.
+Check the @fossyl/zod source for reference: https://github.com/YoyoSaur/fossyl/tree/main/packages/zod`);
+  }
+  if (options.database === "byo") {
+    byoNotes.push(`
+### Database (BYO)
+You need to implement your own database layer. See \`src/db.ts\` for the placeholder.
+Check the @fossyl/kysely source for reference: https://github.com/YoyoSaur/fossyl/tree/main/packages/kysely`);
+  }
+  return `# ${options.name} - AI Development Guide
+
+**Fossyl REST API project**
+
+## Project Structure
+
+\`\`\`
+src/
+\u251C\u2500\u2500 features/
+\u2502   \u2514\u2500\u2500 ping/
+\u2502       \u251C\u2500\u2500 routes/ping.route.ts      # Route definitions
+\u2502       \u251C\u2500\u2500 services/ping.service.ts  # Business logic
+\u2502       \u251C\u2500\u2500 validators/               # Request validators
+\u2502       \u2514\u2500\u2500 repo/ping.repo.ts         # Database access
+\u251C\u2500\u2500 migrations/                       # Database migrations
+\u251C\u2500\u2500 types/
+\u2502   \u2514\u2500\u2500 db.ts                         # Database type definitions
+\u251C\u2500\u2500 db.ts                             # Database setup
+\u2514\u2500\u2500 index.ts                          # Main entry point
+\`\`\`
+
+## Adapters Used
+
+${adapterDocs.join("\n")}
+
+## Quick Start
+
+\`\`\`bash
+# Install dependencies
+pnpm install
+
+# Start development server
+pnpm dev
+\`\`\`
+
+## Adding New Features
+
+1. Create a new feature directory under \`src/features/\`
+2. Add route definitions in \`routes/\`
+3. Add business logic in \`services/\`
+4. Add database access in \`repo/\`
+5. Add validators in \`validators/\`
+6. Register routes in \`src/index.ts\`
+
+## Route Types
+
+Fossyl provides four route types:
+
+- **OpenRoute**: No authentication or body validation
+- **AuthenticatedRoute**: Requires authentication, no body validation
+- **ValidatedRoute**: Requires body validation, no authentication
+- **FullRoute**: Requires both authentication and body validation
+
+## Handler Parameter Order
+
+- Routes with body: \`handler(params, [auth,] body)\`
+- Routes without body: \`handler(params [, auth])\`
+${byoNotes.join("\n")}
+
+## Documentation
+
+- Core: https://github.com/YoyoSaur/fossyl/tree/main/packages/core
+- Express: https://github.com/YoyoSaur/fossyl/tree/main/packages/express
+- Zod: https://github.com/YoyoSaur/fossyl/tree/main/packages/zod
+- Kysely: https://github.com/YoyoSaur/fossyl/tree/main/packages/kysely
+`;
+}
+
+// src/templates/server/express.ts
+function generateExpressIndex(options) {
+  const imports = [
+    "import { createRouter, authWrapper } from '@fossyl/core';",
+    "import { expressAdapter } from '@fossyl/express';"
+  ];
+  if (options.database === "kysely") {
+    imports.push("import { kyselyAdapter } from '@fossyl/kysely';");
+    imports.push("import { db } from './db';");
+    imports.push("import { migrations } from './migrations';");
+  }
+  imports.push("import { pingRoutes } from './features/ping/routes/ping.route';");
+  const adapterConfig = [];
+  if (options.database === "kysely") {
+    adapterConfig.push(`const database = kyselyAdapter({
+  client: db,
+  migrations,
+  autoMigrate: true,
+});`);
+  }
+  const expressOptions = ["cors: true"];
+  if (options.database === "kysely") {
+    expressOptions.push("database");
+  }
+  return `${imports.join("\n")}
+
+// Authentication function (customize based on your auth strategy)
+export const authenticator = async (headers: Record<string, string>) => {
+  // TODO: Implement your authentication logic
+  // Example: JWT verification, OAuth validation, API key check, etc.
+  const userId = headers['x-user-id'];
+  if (!userId) {
+    throw new Error('Unauthorized');
+  }
+  return authWrapper({ userId });
+};
+
+// Create router with base path
+const api = createRouter('/api');
+
+${adapterConfig.join("\n\n")}
+
+// Create Express adapter
+const adapter = expressAdapter({
+  ${expressOptions.join(",\n  ")},
+});
+
+// Register all routes
+const routes = [...pingRoutes(api, authenticator)];
+adapter.register(routes);
+
+// Start server
+const PORT = process.env.PORT ?? 3000;
+adapter.listen(Number(PORT)).then(() => {
+  console.log(\`Server running on http://localhost:\${PORT}\`);
+});
+`;
+}
+function generateByoServerIndex(options) {
+  const imports = [
+    "import { createRouter, authWrapper } from '@fossyl/core';",
+    "import { startServer } from './server';"
+  ];
+  if (options.database === "kysely") {
+    imports.push("import { db } from './db';");
+  }
+  imports.push("import { pingRoutes } from './features/ping/routes/ping.route';");
+  return `${imports.join("\n")}
+
+// Authentication function (customize based on your auth strategy)
+export const authenticator = async (headers: Record<string, string>) => {
+  // TODO: Implement your authentication logic
+  const userId = headers['x-user-id'];
+  if (!userId) {
+    throw new Error('Unauthorized');
+  }
+  return authWrapper({ userId });
+};
+
+// Create router with base path
+const api = createRouter('/api');
+
+// Collect all routes
+const routes = [...pingRoutes(api, authenticator)];
+
+// Start server (implement in ./server.ts)
+const PORT = process.env.PORT ?? 3000;
+startServer(routes, Number(PORT));
+`;
+}
+
+// src/templates/server/byo.ts
+function generateByoServerPlaceholder() {
+  return `import type { Route } from '@fossyl/core';
+
+/**
+ * TODO: Implement your server adapter
+ *
+ * This function should:
+ * 1. Create an HTTP server (Express, Fastify, Hono, etc.)
+ * 2. Register each route from the routes array
+ * 3. Handle request/response transformation
+ * 4. Implement error handling
+ *
+ * Reference implementation: https://github.com/YoyoSaur/fossyl/tree/main/packages/express
+ *
+ * Example with Express:
+ *
+ * import express from 'express';
+ *
+ * export function startServer(routes: Route[], port: number) {
+ *   const app = express();
+ *   app.use(express.json());
+ *
+ *   for (const route of routes) {
+ *     const method = route.method.toLowerCase();
+ *     app[method](route.path, async (req, res) => {
+ *       try {
+ *         // Handle authentication if route.authenticator exists
+ *         // Handle body validation if route.validator exists
+ *         // Call route.handler with appropriate params
+ *         const result = await route.handler(...);
+ *         res.json({ success: 'true', type: result.typeName, data: result });
+ *       } catch (error) {
+ *         res.status(500).json({ success: 'false', error: { message: error.message } });
+ *       }
+ *     });
+ *   }
+ *
+ *   app.listen(port, () => console.log(\`Server running on port \${port}\`));
+ * }
+ */
+export function startServer(routes: Route[], port: number): void {
+  // TODO: Implement your server
+  console.log('TODO: Implement server adapter');
+  console.log(\`Routes to register: \${routes.length}\`);
+  console.log(\`Port: \${port}\`);
+
+  throw new Error('Server adapter not implemented. See src/server.ts for instructions.');
+}
+`;
+}
+
+// src/templates/database/kysely.ts
+function generateKyselySetup() {
+  return `import { Kysely, PostgresDialect } from 'kysely';
+import { Pool } from 'pg';
+import type { DB } from './types/db';
+
+const connectionString = process.env.DATABASE_URL;
+
+if (!connectionString) {
+  throw new Error('DATABASE_URL environment variable is required');
+}
+
+export const db = new Kysely<DB>({
+  dialect: new PostgresDialect({
+    pool: new Pool({ connectionString }),
+  }),
+});
+`;
+}
+function generateDbTypes() {
+  return `import type { Generated, Insertable, Selectable, Updateable } from 'kysely';
+
+// Ping table types
+export interface PingTable {
+  id: Generated<string>;
+  message: string;
+  created_by: string;
+  created_at: Generated<Date>;
+}
+
+export type Ping = Selectable<PingTable>;
+export type NewPing = Insertable<PingTable>;
+export type PingUpdate = Updateable<PingTable>;
+
+// Database schema
+export interface DB {
+  ping: PingTable;
+}
+`;
+}
+function generateMigrationIndex() {
+  return `import { createMigrationProvider } from '@fossyl/kysely';
+import { migration as m001 } from './001_create_ping';
+
+export const migrations = createMigrationProvider({
+  '001_create_ping': m001,
+});
+`;
 }
-function createRouter(_) {
+function generatePingMigration() {
+  return `import { sql } from 'kysely';
+import { defineMigration } from '@fossyl/kysely';
+
+export const migration = defineMigration({
+  async up(db) {
+    await db.schema
+      .createTable('ping')
+      .addColumn('id', 'uuid', (col) =>
+        col.primaryKey().defaultTo(sql\`gen_random_uuid()\`)
+      )
+      .addColumn('message', 'varchar(255)', (col) => col.notNull())
+      .addColumn('created_by', 'varchar(255)', (col) => col.notNull())
+      .addColumn('created_at', 'timestamp', (col) =>
+        col.notNull().defaultTo(sql\`now()\`)
+      )
+      .execute();
+  },
+
+  async down(db) {
+    await db.schema.dropTable('ping').execute();
+  },
+});
+`;
+}
+
+// src/templates/database/byo.ts
+function generateByoDatabasePlaceholder() {
+  return `/**
+ * TODO: Implement your database adapter
+ *
+ * This file should:
+ * 1. Set up your database connection (Prisma, Drizzle, raw SQL, etc.)
+ * 2. Export a database client or query builder
+ * 3. Optionally implement transaction support
+ *
+ * Reference implementation: https://github.com/YoyoSaur/fossyl/tree/main/packages/kysely
+ *
+ * Example with Prisma:
+ *
+ * import { PrismaClient } from '@prisma/client';
+ * export const db = new PrismaClient();
+ *
+ * Example with Drizzle:
+ *
+ * import { drizzle } from 'drizzle-orm/postgres-js';
+ * import postgres from 'postgres';
+ * const queryClient = postgres(process.env.DATABASE_URL!);
+ * export const db = drizzle(queryClient);
+ */
+
+// Placeholder - replace with your database client
+export const db = {
+  // Add your database client here
+  query: async (sql: string, params?: unknown[]) => {
+    throw new Error('Database not implemented. See src/db.ts for instructions.');
+  },
+};
+`;
+}
+
+// src/templates/validator/zod.ts
+function generateZodValidators() {
+  return `import { z } from 'zod';
+import { zodValidator, zodQueryValidator } from '@fossyl/zod';
+
+// Create ping body schema
+export const createPingSchema = z.object({
+  message: z.string().min(1).max(255),
+});
+
+export const createPingValidator = zodValidator(createPingSchema);
+export type CreatePingBody = z.infer<typeof createPingSchema>;
+
+// Update ping body schema
+export const updatePingSchema = z.object({
+  message: z.string().min(1).max(255).optional(),
+});
+
+export const updatePingValidator = zodValidator(updatePingSchema);
+export type UpdatePingBody = z.infer<typeof updatePingSchema>;
+
+// List ping query schema
+export const listPingQuerySchema = z.object({
+  limit: z.coerce.number().min(1).max(100).default(10),
+  offset: z.coerce.number().min(0).default(0),
+});
+
+export const listPingQueryValidator = zodQueryValidator(listPingQuerySchema);
+export type ListPingQuery = z.infer<typeof listPingQuerySchema>;
+`;
+}
+
+// src/templates/validator/byo.ts
+function generateByoValidatorPlaceholder() {
+  return `/**
+ * TODO: Implement your validators
+ *
+ * Validators should:
+ * 1. Accept unknown data
+ * 2. Validate and parse the data
+ * 3. Return the typed result or throw an error
+ *
+ * Reference implementation: https://github.com/YoyoSaur/fossyl/tree/main/packages/zod
+ *
+ * Example with Yup:
+ *
+ * import * as yup from 'yup';
+ *
+ * const createPingSchema = yup.object({
+ *   message: yup.string().required().max(255),
+ * });
+ *
+ * export const createPingValidator = (data: unknown) => {
+ *   return createPingSchema.validateSync(data);
+ * };
+ *
+ * Example with manual validation:
+ *
+ * export const createPingValidator = (data: unknown): CreatePingBody => {
+ *   if (typeof data !== 'object' || data === null) {
+ *     throw new Error('Invalid request body');
+ *   }
+ *   const { message } = data as Record<string, unknown>;
+ *   if (typeof message !== 'string' || message.length === 0 || message.length > 255) {
+ *     throw new Error('Invalid message');
+ *   }
+ *   return { message };
+ * };
+ */
+
+// Type definitions
+export interface CreatePingBody {
+  message: string;
+}
+
+export interface UpdatePingBody {
+  message?: string;
+}
+
+export interface ListPingQuery {
+  limit: number;
+  offset: number;
+}
+
+// Validators - TODO: Implement actual validation
+export const createPingValidator = (data: unknown): CreatePingBody => {
+  // TODO: Add validation logic
+  return data as CreatePingBody;
+};
+
+export const updatePingValidator = (data: unknown): UpdatePingBody => {
+  // TODO: Add validation logic
+  return data as UpdatePingBody;
+};
+
+export const listPingQueryValidator = (data: unknown): ListPingQuery => {
+  // TODO: Add validation logic
+  const parsed = data as Record<string, unknown>;
   return {
-    createEndpoint: (path) => createEndpoint(path),
-    createSubrouter: (path) => createRouter(path)
+    limit: Number(parsed.limit) || 10,
+    offset: Number(parsed.offset) || 0,
   };
+};
+`;
 }
 
-// src/router/types/routes.types.ts
-function authWrapper(auth) {
-  return __spreadProps(__spreadValues({}, auth), {
-    [authBrand]: "Auth"
+// src/templates/feature/ping.ts
+function generatePingRoute(options) {
+  const validatorImport = options.validator === "zod" ? `import {
+  createPingValidator,
+  updatePingValidator,
+  listPingQueryValidator,
+} from '../validators/ping.validators';` : `import {
+  createPingValidator,
+  updatePingValidator,
+  listPingQueryValidator,
+} from '../validators/ping.validators';`;
+  return `import type { Router, AuthenticationFunction } from '@fossyl/core';
+import * as pingService from '../services/ping.service';
+${validatorImport}
+
+/**
+ * Ping feature routes demonstrating all 4 route types:
+ * - OpenRoute: GET /api/ping (list all)
+ * - OpenRoute: GET /api/ping/:id (get one)
+ * - FullRoute: POST /api/ping (authenticated + validated)
+ * - FullRoute: PUT /api/ping/:id (authenticated + validated)
+ * - AuthenticatedRoute: DELETE /api/ping/:id (authenticated only)
+ */
+export function pingRoutes<T extends { userId: string }>(
+  router: Router,
+  authenticator: AuthenticationFunction<T>
+) {
+  // OpenRoute - List all pings (public)
+  const listPings = router.createEndpoint('/ping').get({
+    queryValidator: listPingQueryValidator,
+    handler: async ({ query }) => {
+      const pings = await pingService.listPings(query.limit, query.offset);
+      return {
+        typeName: 'PingList' as const,
+        pings,
+        limit: query.limit,
+        offset: query.offset,
+      };
+    },
+  });
+
+  // OpenRoute - Get single ping (public)
+  const getPing = router.createEndpoint('/ping/:id').get({
+    handler: async ({ url }) => {
+      const ping = await pingService.getPing(url.id);
+      return {
+        typeName: 'Ping' as const,
+        ...ping,
+      };
+    },
+  });
+
+  // FullRoute - Create ping (authenticated + validated)
+  const createPing = router.createEndpoint('/ping').post({
+    authenticator,
+    validator: createPingValidator,
+    handler: async ({ url }, auth, body) => {
+      const ping = await pingService.createPing(body.message, auth.userId);
+      return {
+        typeName: 'Ping' as const,
+        ...ping,
+      };
+    },
+  });
+
+  // FullRoute - Update ping (authenticated + validated)
+  const updatePing = router.createEndpoint('/ping/:id').put({
+    authenticator,
+    validator: updatePingValidator,
+    handler: async ({ url }, auth, body) => {
+      const ping = await pingService.updatePing(url.id, body, auth.userId);
+      return {
+        typeName: 'Ping' as const,
+        ...ping,
+      };
+    },
+  });
+
+  // AuthenticatedRoute - Delete ping (authenticated only, no body)
+  const deletePing = router.createEndpoint('/ping/:id').delete({
+    authenticator,
+    handler: async ({ url }, auth) => {
+      await pingService.deletePing(url.id, auth.userId);
+      return {
+        typeName: 'DeleteResult' as const,
+        id: url.id,
+        deleted: true,
+      };
+    },
   });
+
+  return [listPings, getPing, createPing, updatePing, deletePing];
+}
+`;
+}
+function generatePingService(_options) {
+  return `import * as pingRepo from '../repo/ping.repo';
+
+export interface PingData {
+  id: string;
+  message: string;
+  created_by: string;
+  created_at: Date;
+}
+
+export async function listPings(limit: number, offset: number): Promise<PingData[]> {
+  return pingRepo.findAll(limit, offset);
+}
+
+export async function getPing(id: string): Promise<PingData> {
+  const ping = await pingRepo.findById(id);
+  if (!ping) {
+    throw new Error('Ping not found');
+  }
+  return ping;
+}
+
+export async function createPing(message: string, userId: string): Promise<PingData> {
+  return pingRepo.create({ message, created_by: userId });
+}
+
+export async function updatePing(
+  id: string,
+  data: { message?: string },
+  userId: string
+): Promise<PingData> {
+  const existing = await pingRepo.findById(id);
+  if (!existing) {
+    throw new Error('Ping not found');
+  }
+  // Optional: Check if user owns the ping
+  // if (existing.created_by !== userId) {
+  //   throw new Error('Not authorized');
+  // }
+  return pingRepo.update(id, data);
+}
+
+export async function deletePing(id: string, userId: string): Promise<void> {
+  const existing = await pingRepo.findById(id);
+  if (!existing) {
+    throw new Error('Ping not found');
+  }
+  // Optional: Check if user owns the ping
+  // if (existing.created_by !== userId) {
+  //   throw new Error('Not authorized');
+  // }
+  await pingRepo.remove(id);
+}
+`;
+}
+function generatePingRepo(options) {
+  if (options.database === "kysely") {
+    return generateKyselyPingRepo();
+  }
+  return generateByoPingRepo();
+}
+function generateKyselyPingRepo() {
+  return `import { getTransaction } from '@fossyl/kysely';
+import type { DB, Ping, NewPing, PingUpdate } from '../../../types/db';
+
+export async function findAll(limit: number, offset: number): Promise<Ping[]> {
+  const db = getTransaction<DB>();
+  return db
+    .selectFrom('ping')
+    .selectAll()
+    .orderBy('created_at', 'desc')
+    .limit(limit)
+    .offset(offset)
+    .execute();
+}
+
+export async function findById(id: string): Promise<Ping | undefined> {
+  const db = getTransaction<DB>();
+  return db
+    .selectFrom('ping')
+    .where('id', '=', id)
+    .selectAll()
+    .executeTakeFirst();
+}
+
+export async function create(data: Omit<NewPing, 'id' | 'created_at'>): Promise<Ping> {
+  const db = getTransaction<DB>();
+  return db
+    .insertInto('ping')
+    .values(data)
+    .returningAll()
+    .executeTakeFirstOrThrow();
+}
+
+export async function update(id: string, data: PingUpdate): Promise<Ping> {
+  const db = getTransaction<DB>();
+  return db
+    .updateTable('ping')
+    .set(data)
+    .where('id', '=', id)
+    .returningAll()
+    .executeTakeFirstOrThrow();
+}
+
+export async function remove(id: string): Promise<void> {
+  const db = getTransaction<DB>();
+  await db.deleteFrom('ping').where('id', '=', id).execute();
+}
+`;
+}
+function generateByoPingRepo() {
+  return `/**
+ * TODO: Implement database operations
+ *
+ * This file contains placeholder implementations.
+ * Replace with your actual database queries using your chosen database client.
+ */
+
+export interface Ping {
+  id: string;
+  message: string;
+  created_by: string;
+  created_at: Date;
+}
+
+// In-memory store for demo purposes - replace with actual database
+const pings: Map<string, Ping> = new Map();
+
+export async function findAll(limit: number, offset: number): Promise<Ping[]> {
+  // TODO: Replace with actual database query
+  const all = Array.from(pings.values());
+  return all.slice(offset, offset + limit);
+}
+
+export async function findById(id: string): Promise<Ping | undefined> {
+  // TODO: Replace with actual database query
+  return pings.get(id);
+}
+
+export async function create(data: { message: string; created_by: string }): Promise<Ping> {
+  // TODO: Replace with actual database insert
+  const ping: Ping = {
+    id: crypto.randomUUID(),
+    message: data.message,
+    created_by: data.created_by,
+    created_at: new Date(),
+  };
+  pings.set(ping.id, ping);
+  return ping;
+}
+
+export async function update(id: string, data: { message?: string }): Promise<Ping> {
+  // TODO: Replace with actual database update
+  const existing = pings.get(id);
+  if (!existing) {
+    throw new Error('Not found');
+  }
+  const updated = { ...existing, ...data };
+  pings.set(id, updated);
+  return updated;
+}
+
+export async function remove(id: string): Promise<void> {
+  // TODO: Replace with actual database delete
+  pings.delete(id);
+}
+`;
+}
+
+// src/scaffold.ts
+function generateFiles(options) {
+  const files = [];
+  files.push({
+    path: "package.json",
+    content: generatePackageJson(options)
+  });
+  files.push({
+    path: "tsconfig.json",
+    content: generateTsConfig()
+  });
+  files.push({
+    path: ".env.example",
+    content: generateEnvExample(options)
+  });
+  files.push({
+    path: "CLAUDE.md",
+    content: generateClaudeMd(options)
+  });
+  if (options.server === "express") {
+    files.push({
+      path: "src/index.ts",
+      content: generateExpressIndex(options)
+    });
+  } else {
+    files.push({
+      path: "src/index.ts",
+      content: generateByoServerIndex(options)
+    });
+    files.push({
+      path: "src/server.ts",
+      content: generateByoServerPlaceholder()
+    });
+  }
+  if (options.database === "kysely") {
+    files.push({
+      path: "src/db.ts",
+      content: generateKyselySetup()
+    });
+    files.push({
+      path: "src/types/db.ts",
+      content: generateDbTypes()
+    });
+    files.push({
+      path: "src/migrations/index.ts",
+      content: generateMigrationIndex()
+    });
+    files.push({
+      path: "src/migrations/001_create_ping.ts",
+      content: generatePingMigration()
+    });
+  } else {
+    files.push({
+      path: "src/db.ts",
+      content: generateByoDatabasePlaceholder()
+    });
+    files.push({
+      path: "src/types/db.ts",
+      content: "// TODO: Define your database types here\nexport interface DB {}\n"
+    });
+  }
+  if (options.validator === "zod") {
+    files.push({
+      path: "src/features/ping/validators/ping.validators.ts",
+      content: generateZodValidators()
+    });
+  } else {
+    files.push({
+      path: "src/features/ping/validators/ping.validators.ts",
+      content: generateByoValidatorPlaceholder()
+    });
+  }
+  files.push({
+    path: "src/features/ping/routes/ping.route.ts",
+    content: generatePingRoute(options)
+  });
+  files.push({
+    path: "src/features/ping/services/ping.service.ts",
+    content: generatePingService(options)
+  });
+  files.push({
+    path: "src/features/ping/repo/ping.repo.ts",
+    content: generatePingRepo(options)
+  });
+  return files;
+}
+function writeFiles(projectPath, files) {
+  for (const file of files) {
+    const fullPath = path.join(projectPath, file.path);
+    const dir = path.dirname(fullPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(fullPath, file.content, "utf-8");
+  }
+}
+
+// src/commands/create.ts
+async function createCommand(projectName) {
+  const options = await promptForOptions(projectName);
+  if (!options) {
+    return;
+  }
+  const projectPath = options.name === "." ? process.cwd() : path2.resolve(process.cwd(), options.name);
+  if (options.name !== ".") {
+    if (fs2.existsSync(projectPath)) {
+      const files = fs2.readdirSync(projectPath);
+      if (files.length > 0) {
+        p2.cancel(`Directory "${options.name}" already exists and is not empty.`);
+        return;
+      }
+    }
+  }
+  const s = p2.spinner();
+  s.start("Creating project files...");
+  try {
+    const files = generateFiles(options);
+    writeFiles(projectPath, files);
+    s.stop("Project files created!");
+    p2.note(
+      `cd ${options.name === "." ? "." : options.name}
+pnpm install
+pnpm dev`,
+      "Next steps"
+    );
+    const adapters = [];
+    if (options.server === "express") adapters.push("@fossyl/express");
+    if (options.validator === "zod") adapters.push("@fossyl/zod");
+    if (options.database === "kysely") adapters.push("@fossyl/kysely");
+    if (adapters.length > 0) {
+      p2.log.info(`Using fossyl adapters: ${adapters.join(", ")}`);
+    }
+    if (options.server === "byo" || options.validator === "byo" || options.database === "byo") {
+      p2.log.warn("Check TODO comments in generated files for BYO setup instructions.");
+    }
+    p2.outro("Happy coding!");
+  } catch (error) {
+    s.stop("Failed to create project files.");
+    throw error;
+  }
+}
+
+// src/index.ts
+var { values, positionals } = (0, import_node_util.parseArgs)({
+  options: {
+    create: { type: "boolean" },
+    help: { type: "boolean", short: "h" },
+    version: { type: "boolean", short: "v" }
+  },
+  allowPositionals: true
+});
+function showHelp() {
+  console.log(`
+fossyl - CLI for scaffolding fossyl projects
+
+Usage:
+  npx fossyl --create <project-name>   Create a new fossyl project
+  npx fossyl --help                    Show this help message
+  npx fossyl --version                 Show version
+
+Examples:
+  npx fossyl --create my-api           Create a new project named "my-api"
+  npx fossyl --create .                Create a new project in the current directory
+`);
+}
+function showVersion() {
+  console.log("fossyl v0.9.0");
+}
+async function main() {
+  if (values.version) {
+    showVersion();
+  } else if (values.create) {
+    await createCommand(positionals[0]);
+  } else if (values.help) {
+    showHelp();
+  } else {
+    showHelp();
+  }
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  authWrapper,
-  createRouter
+main().catch((error) => {
+  console.error("Error:", error.message);
+  process.exit(1);
 });