@effect-gql/cli 1.1.0 → 1.3.0

package/bin.cjs

@@ -3,8 +3,10 @@
 
 var effect = require('effect');
 var core = require('@effect-gql/core');
-var fs = require('fs');
-var path = require('path');
+var fs3 = require('fs');
+var path2 = require('path');
+var readline = require('readline');
+var child_process = require('child_process');
 
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
@@ -24,8 +26,9 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
-var path__namespace = /*#__PURE__*/_interopNamespace(path);
+var fs3__namespace = /*#__PURE__*/_interopNamespace(fs3);
+var path2__namespace = /*#__PURE__*/_interopNamespace(path2);
+var readline__namespace = /*#__PURE__*/_interopNamespace(readline);
 
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
@@ -34,8 +37,8 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 var loadSchema = (modulePath) => effect.Effect.gen(function* () {
-  const absolutePath = path__namespace.resolve(process.cwd(), modulePath);
-  if (!fs__namespace.existsSync(absolutePath)) {
+  const absolutePath = path2__namespace.resolve(process.cwd(), modulePath);
+  if (!fs3__namespace.existsSync(absolutePath)) {
     return yield* effect.Effect.fail(new Error(`File not found: ${absolutePath}`));
   }
   const module = yield* effect.Effect.tryPromise({
@@ -76,20 +79,20 @@ var run = (options) => effect.Effect.gen(function* () {
   const schema = yield* loadSchema(options.modulePath);
   const sdl = generateSDL(schema, { sort: options.sort });
   if (options.output) {
-    const outputPath = path__namespace.resolve(process.cwd(), options.output);
-    fs__namespace.writeFileSync(outputPath, sdl);
+    const outputPath = path2__namespace.resolve(process.cwd(), options.output);
+    fs3__namespace.writeFileSync(outputPath, sdl);
     yield* effect.Console.log(`Schema written to ${outputPath}`);
   } else {
     yield* effect.Console.log(sdl);
   }
 });
 var watch2 = (options) => effect.Effect.gen(function* () {
-  const absolutePath = path__namespace.resolve(process.cwd(), options.modulePath);
-  const dir = path__namespace.dirname(absolutePath);
+  const absolutePath = path2__namespace.resolve(process.cwd(), options.modulePath);
+  const dir = path2__namespace.dirname(absolutePath);
   yield* effect.Console.log(`Watching for changes in ${dir}...`);
   yield* run(options).pipe(effect.Effect.catchAll((error) => effect.Console.error(`Error: ${error.message}`)));
   yield* effect.Effect.async(() => {
-    const watcher = fs__namespace.watch(dir, { recursive: true }, (_, filename) => {
+    const watcher = fs3__namespace.watch(dir, { recursive: true }, (_, filename) => {
       if (filename?.endsWith(".ts") || filename?.endsWith(".js")) {
         effect.Effect.runPromise(
           run(options).pipe(
@@ -179,6 +182,1122 @@ var runGenerateSchema = (args) => effect.Effect.gen(function* () {
   }
 });
 
+// src/commands/create/types.ts
+var SERVER_TYPES = ["node", "bun", "express", "web"];
+var isValidServerType = (value) => SERVER_TYPES.includes(value);
+var PACKAGE_MANAGERS = ["npm", "pnpm", "yarn", "bun"];
+var isValidPackageManager = (value) => PACKAGE_MANAGERS.includes(value);
+
+// src/commands/create/args.ts
+var parseArgs2 = (args) => {
+  const positional = [];
+  let serverType;
+  let directory = effect.Option.none();
+  let monorepo = effect.Option.none();
+  let skipInstall = false;
+  let packageManager = effect.Option.none();
+  let interactive = false;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "-h" || arg === "--help") {
+      return { help: true };
+    } else if (arg === "-i" || arg === "--interactive") {
+      interactive = true;
+    } else if (arg === "-s" || arg === "--server-type") {
+      const value = args[++i];
+      if (!value) {
+        return { error: "Missing value for --server-type" };
+      }
+      if (!isValidServerType(value)) {
+        return {
+          error: `Invalid server type: ${value}. Must be one of: ${SERVER_TYPES.join(", ")}`
+        };
+      }
+      serverType = value;
+    } else if (arg === "-d" || arg === "--directory") {
+      const value = args[++i];
+      if (!value) {
+        return { error: "Missing value for --directory" };
+      }
+      directory = effect.Option.some(value);
+    } else if (arg === "--monorepo") {
+      monorepo = effect.Option.some(true);
+    } else if (arg === "--skip-install") {
+      skipInstall = true;
+    } else if (arg === "--package-manager") {
+      const value = args[++i];
+      if (!value) {
+        return { error: "Missing value for --package-manager" };
+      }
+      if (!isValidPackageManager(value)) {
+        return { error: `Invalid package manager: ${value}. Must be one of: npm, pnpm, yarn, bun` };
+      }
+      packageManager = effect.Option.some(value);
+    } else if (!arg.startsWith("-")) {
+      positional.push(arg);
+    } else {
+      return { error: `Unknown option: ${arg}` };
+    }
+  }
+  if (interactive) {
+    return { interactive: true };
+  }
+  if (args.length === 0) {
+    return { interactive: true };
+  }
+  if (positional.length === 0) {
+    return {
+      error: "Missing project name. Use --interactive or provide: effect-gql create <name> --server-type <type>"
+    };
+  }
+  if (!serverType) {
+    return { error: "Missing --server-type. Must be one of: " + SERVER_TYPES.join(", ") };
+  }
+  const options = {
+    name: positional[0],
+    serverType,
+    directory,
+    monorepo,
+    skipInstall,
+    packageManager
+  };
+  return { options };
+};
+
+// src/commands/create/templates/package-json.ts
+var VERSIONS = {
+  core: "^1.3.0",
+  node: "^1.3.0",
+  bun: "^1.3.0",
+  express: "^1.3.0",
+  web: "^1.3.0",
+  effect: "^3.19.0",
+  platform: "^0.94.0",
+  platformNode: "^0.104.0",
+  platformBun: "^0.87.0",
+  graphql: "^16.0.0",
+  expressLib: "^5.0.0",
+  tsx: "^4.19.0",
+  typescript: "^5.0.0"
+};
+var getDependencies = (serverType, _isMonorepo) => {
+  const baseDeps = {
+    "@effect-gql/core": VERSIONS.core,
+    "@effect/platform": VERSIONS.platform,
+    effect: VERSIONS.effect,
+    graphql: VERSIONS.graphql
+  };
+  const baseDevDeps = {
+    tsx: VERSIONS.tsx,
+    typescript: VERSIONS.typescript
+  };
+  switch (serverType) {
+    case "node":
+      return {
+        dependencies: {
+          ...baseDeps,
+          "@effect-gql/node": VERSIONS.node,
+          "@effect/platform-node": VERSIONS.platformNode
+        },
+        devDependencies: baseDevDeps
+      };
+    case "bun":
+      return {
+        dependencies: {
+          ...baseDeps,
+          "@effect-gql/bun": VERSIONS.bun,
+          "@effect/platform-bun": VERSIONS.platformBun
+        },
+        devDependencies: {
+          typescript: VERSIONS.typescript
+          // Bun has built-in TypeScript support, no tsx needed
+        }
+      };
+    case "express":
+      return {
+        dependencies: {
+          ...baseDeps,
+          "@effect-gql/express": VERSIONS.express,
+          express: VERSIONS.expressLib
+        },
+        devDependencies: {
+          ...baseDevDeps,
+          "@types/express": "^5.0.0"
+        }
+      };
+    case "web":
+      return {
+        dependencies: {
+          ...baseDeps,
+          "@effect-gql/web": VERSIONS.web
+        },
+        devDependencies: baseDevDeps
+      };
+  }
+};
+var getScripts = (serverType) => {
+  switch (serverType) {
+    case "node":
+      return {
+        start: "tsx src/index.ts",
+        dev: "tsx watch src/index.ts",
+        build: "tsc",
+        typecheck: "tsc --noEmit"
+      };
+    case "bun":
+      return {
+        start: "bun run src/index.ts",
+        dev: "bun --watch src/index.ts",
+        build: "bun build src/index.ts --outdir dist --target bun",
+        typecheck: "tsc --noEmit"
+      };
+    case "express":
+      return {
+        start: "tsx src/index.ts",
+        dev: "tsx watch src/index.ts",
+        build: "tsc",
+        typecheck: "tsc --noEmit"
+      };
+    case "web":
+      return {
+        start: "tsx src/index.ts",
+        dev: "tsx watch src/index.ts",
+        build: "tsc",
+        typecheck: "tsc --noEmit"
+        // Users will typically add wrangler/deno commands as needed
+      };
+  }
+};
+var generatePackageJson = (ctx) => {
+  const deps = getDependencies(ctx.serverType);
+  const pkg = {
+    name: ctx.name,
+    version: "0.0.1",
+    private: true,
+    type: "module",
+    scripts: getScripts(ctx.serverType),
+    dependencies: deps.dependencies,
+    devDependencies: deps.devDependencies
+  };
+  return JSON.stringify(pkg, null, 2) + "\n";
+};
+
+// src/commands/create/templates/tsconfig.ts
+var generateTsConfig = (ctx) => {
+  const config = ctx.isMonorepo ? {
+    // In a monorepo, extend from root tsconfig
+    extends: "../../tsconfig.json",
+    compilerOptions: {
+      outDir: "./dist",
+      rootDir: "./src",
+      noEmit: true
+    },
+    include: ["src/**/*"],
+    exclude: ["node_modules", "dist"]
+  } : {
+    // Standalone project config
+    compilerOptions: {
+      target: "ES2022",
+      module: "NodeNext",
+      moduleResolution: "NodeNext",
+      lib: ["ES2022"],
+      outDir: "./dist",
+      rootDir: "./src",
+      strict: true,
+      esModuleInterop: true,
+      skipLibCheck: true,
+      forceConsistentCasingInFileNames: true,
+      declaration: true,
+      declarationMap: true,
+      sourceMap: true,
+      noEmit: true,
+      // Effect requires these for decorators
+      experimentalDecorators: true,
+      emitDecoratorMetadata: true
+    },
+    include: ["src/**/*"],
+    exclude: ["node_modules", "dist"]
+  };
+  return JSON.stringify(config, null, 2) + "\n";
+};
+
+// src/commands/create/templates/server.ts
+var generateNodeServer = (ctx) => `/**
+ * ${ctx.name} - GraphQL Server
+ *
+ * A GraphQL server built with Effect GQL and Node.js.
+ */
+
+import { Effect, Layer } from "effect"
+import * as S from "effect/Schema"
+import { HttpRouter, HttpServerResponse } from "@effect/platform"
+import { GraphQLSchemaBuilder, query, mutation, makeGraphQLRouter } from "@effect-gql/core"
+import { serve } from "@effect-gql/node"
+
+// =============================================================================
+// Domain Models
+// =============================================================================
+
+/**
+ * Define your types with Effect Schema.
+ * This single definition is used for both TypeScript types AND GraphQL types.
+ */
+const User = S.Struct({
+  id: S.String,
+  name: S.String,
+  email: S.String,
+})
+
+type User = S.Schema.Type<typeof User>
+
+// =============================================================================
+// In-Memory Data Store (replace with your database)
+// =============================================================================
+
+const users: User[] = [
+  { id: "1", name: "Alice", email: "alice@example.com" },
+  { id: "2", name: "Bob", email: "bob@example.com" },
+]
+
+// =============================================================================
+// GraphQL Schema
+// =============================================================================
+
+const schema = GraphQLSchemaBuilder.empty
+  .pipe(
+    // Simple query
+    query("hello", {
+      type: S.String,
+      description: "Returns a friendly greeting",
+      resolve: () => Effect.succeed("Hello from ${ctx.name}!"),
+    }),
+
+    // Query with arguments
+    query("user", {
+      args: S.Struct({ id: S.String }),
+      type: S.NullOr(User),
+      description: "Get a user by ID",
+      resolve: (args) => Effect.succeed(users.find((u) => u.id === args.id) ?? null),
+    }),
+
+    // Query that returns a list
+    query("users", {
+      type: S.Array(User),
+      description: "Get all users",
+      resolve: () => Effect.succeed(users),
+    }),
+
+    // Mutation
+    mutation("createUser", {
+      args: S.Struct({
+        name: S.String,
+        email: S.String,
+      }),
+      type: User,
+      description: "Create a new user",
+      resolve: (args) =>
+        Effect.sync(() => {
+          const newUser: User = {
+            id: String(users.length + 1),
+            name: args.name,
+            email: args.email,
+          }
+          users.push(newUser)
+          return newUser
+        }),
+    })
+  )
+  .buildSchema()
+
+// =============================================================================
+// HTTP Router
+// =============================================================================
+
+const graphqlRouter = makeGraphQLRouter(schema, Layer.empty, {
+  path: "/graphql",
+  graphiql: {
+    path: "/graphiql",
+    endpoint: "/graphql",
+  },
+})
+
+const router = HttpRouter.empty.pipe(
+  HttpRouter.get("/health", HttpServerResponse.json({ status: "ok" })),
+  HttpRouter.concat(graphqlRouter)
+)
+
+// =============================================================================
+// Server Startup
+// =============================================================================
+
+serve(router, Layer.empty, {
+  port: 4000,
+  onStart: (url: string) => {
+    console.log(\`Server ready at \${url}\`)
+    console.log(\`GraphQL endpoint: \${url}/graphql\`)
+    console.log(\`GraphiQL playground: \${url}/graphiql\`)
+    console.log(\`Health check: \${url}/health\`)
+  },
+})
+`;
+var generateBunServer = (ctx) => `/**
+ * ${ctx.name} - GraphQL Server
+ *
+ * A GraphQL server built with Effect GQL and Bun.
+ */
+
+import { Effect, Layer } from "effect"
+import * as S from "effect/Schema"
+import { HttpRouter, HttpServerResponse } from "@effect/platform"
+import { GraphQLSchemaBuilder, query, mutation, makeGraphQLRouter } from "@effect-gql/core"
+import { serve } from "@effect-gql/bun"
+
+// =============================================================================
+// Domain Models
+// =============================================================================
+
+const User = S.Struct({
+  id: S.String,
+  name: S.String,
+  email: S.String,
+})
+
+type User = S.Schema.Type<typeof User>
+
+// =============================================================================
+// In-Memory Data Store (replace with your database)
+// =============================================================================
+
+const users: User[] = [
+  { id: "1", name: "Alice", email: "alice@example.com" },
+  { id: "2", name: "Bob", email: "bob@example.com" },
+]
+
+// =============================================================================
+// GraphQL Schema
+// =============================================================================
+
+const schema = GraphQLSchemaBuilder.empty
+  .pipe(
+    query("hello", {
+      type: S.String,
+      description: "Returns a friendly greeting",
+      resolve: () => Effect.succeed("Hello from ${ctx.name}!"),
+    }),
+
+    query("user", {
+      args: S.Struct({ id: S.String }),
+      type: S.NullOr(User),
+      description: "Get a user by ID",
+      resolve: (args) => Effect.succeed(users.find((u) => u.id === args.id) ?? null),
+    }),
+
+    query("users", {
+      type: S.Array(User),
+      description: "Get all users",
+      resolve: () => Effect.succeed(users),
+    }),
+
+    mutation("createUser", {
+      args: S.Struct({
+        name: S.String,
+        email: S.String,
+      }),
+      type: User,
+      description: "Create a new user",
+      resolve: (args) =>
+        Effect.sync(() => {
+          const newUser: User = {
+            id: String(users.length + 1),
+            name: args.name,
+            email: args.email,
+          }
+          users.push(newUser)
+          return newUser
+        }),
+    })
+  )
+  .buildSchema()
+
+// =============================================================================
+// HTTP Router
+// =============================================================================
+
+const graphqlRouter = makeGraphQLRouter(schema, Layer.empty, {
+  path: "/graphql",
+  graphiql: {
+    path: "/graphiql",
+    endpoint: "/graphql",
+  },
+})
+
+const router = HttpRouter.empty.pipe(
+  HttpRouter.get("/health", HttpServerResponse.json({ status: "ok" })),
+  HttpRouter.concat(graphqlRouter)
+)
+
+// =============================================================================
+// Server Startup
+// =============================================================================
+
+serve(router, Layer.empty, {
+  port: 4000,
+  onStart: (url: string) => {
+    console.log(\`Server ready at \${url}\`)
+    console.log(\`GraphQL endpoint: \${url}/graphql\`)
+    console.log(\`GraphiQL playground: \${url}/graphiql\`)
+    console.log(\`Health check: \${url}/health\`)
+  },
+})
+`;
+var generateExpressServer = (ctx) => `/**
+ * ${ctx.name} - GraphQL Server
+ *
+ * A GraphQL server built with Effect GQL and Express.
+ */
+
+import express from "express"
+import { Effect, Layer } from "effect"
+import * as S from "effect/Schema"
+import { GraphQLSchemaBuilder, query, mutation, makeGraphQLRouter } from "@effect-gql/core"
+import { toMiddleware } from "@effect-gql/express"
+
+// =============================================================================
+// Domain Models
+// =============================================================================
+
+const User = S.Struct({
+  id: S.String,
+  name: S.String,
+  email: S.String,
+})
+
+type User = S.Schema.Type<typeof User>
+
+// =============================================================================
+// In-Memory Data Store (replace with your database)
+// =============================================================================
+
+const users: User[] = [
+  { id: "1", name: "Alice", email: "alice@example.com" },
+  { id: "2", name: "Bob", email: "bob@example.com" },
+]
+
+// =============================================================================
+// GraphQL Schema
+// =============================================================================
+
+const schema = GraphQLSchemaBuilder.empty
+  .pipe(
+    query("hello", {
+      type: S.String,
+      description: "Returns a friendly greeting",
+      resolve: () => Effect.succeed("Hello from ${ctx.name}!"),
+    }),
+
+    query("user", {
+      args: S.Struct({ id: S.String }),
+      type: S.NullOr(User),
+      description: "Get a user by ID",
+      resolve: (args) => Effect.succeed(users.find((u) => u.id === args.id) ?? null),
+    }),
+
+    query("users", {
+      type: S.Array(User),
+      description: "Get all users",
+      resolve: () => Effect.succeed(users),
+    }),
+
+    mutation("createUser", {
+      args: S.Struct({
+        name: S.String,
+        email: S.String,
+      }),
+      type: User,
+      description: "Create a new user",
+      resolve: (args) =>
+        Effect.sync(() => {
+          const newUser: User = {
+            id: String(users.length + 1),
+            name: args.name,
+            email: args.email,
+          }
+          users.push(newUser)
+          return newUser
+        }),
+    })
+  )
+  .buildSchema()
+
+// =============================================================================
+// GraphQL Router
+// =============================================================================
+
+const graphqlRouter = makeGraphQLRouter(schema, Layer.empty, {
+  path: "/graphql",
+  graphiql: {
+    path: "/graphiql",
+    endpoint: "/graphql",
+  },
+})
+
+// =============================================================================
+// Express App
+// =============================================================================
+
+const app = express()
+app.use(express.json())
+
+// Health check
+app.get("/health", (_, res) => {
+  res.json({ status: "ok" })
+})
+
+// Mount GraphQL middleware
+app.use(toMiddleware(graphqlRouter, Layer.empty))
+
+// =============================================================================
+// Server Startup
+// =============================================================================
+
+const port = process.env.PORT || 4000
+
+app.listen(port, () => {
+  console.log(\`Server ready at http://localhost:\${port}\`)
+  console.log(\`GraphQL endpoint: http://localhost:\${port}/graphql\`)
+  console.log(\`GraphiQL playground: http://localhost:\${port}/graphiql\`)
+  console.log(\`Health check: http://localhost:\${port}/health\`)
+})
+`;
+var generateWebHandler = (ctx) => `/**
+ * ${ctx.name} - GraphQL Server
+ *
+ * A GraphQL server built with Effect GQL using Web standard APIs.
+ * Compatible with Cloudflare Workers, Deno, and other WASM runtimes.
+ */
+
+import { Effect, Layer } from "effect"
+import * as S from "effect/Schema"
+import { GraphQLSchemaBuilder, query, mutation, makeGraphQLRouter } from "@effect-gql/core"
+import { toHandler } from "@effect-gql/web"
+
+// =============================================================================
+// Domain Models
+// =============================================================================
+
+const User = S.Struct({
+  id: S.String,
+  name: S.String,
+  email: S.String,
+})
+
+type User = S.Schema.Type<typeof User>
+
+// =============================================================================
+// In-Memory Data Store (replace with your database)
+// =============================================================================
+
+const users: User[] = [
+  { id: "1", name: "Alice", email: "alice@example.com" },
+  { id: "2", name: "Bob", email: "bob@example.com" },
+]
+
+// =============================================================================
+// GraphQL Schema
+// =============================================================================
+
+const schema = GraphQLSchemaBuilder.empty
+  .pipe(
+    query("hello", {
+      type: S.String,
+      description: "Returns a friendly greeting",
+      resolve: () => Effect.succeed("Hello from ${ctx.name}!"),
+    }),
+
+    query("user", {
+      args: S.Struct({ id: S.String }),
+      type: S.NullOr(User),
+      description: "Get a user by ID",
+      resolve: (args) => Effect.succeed(users.find((u) => u.id === args.id) ?? null),
+    }),
+
+    query("users", {
+      type: S.Array(User),
+      description: "Get all users",
+      resolve: () => Effect.succeed(users),
+    }),
+
+    mutation("createUser", {
+      args: S.Struct({
+        name: S.String,
+        email: S.String,
+      }),
+      type: User,
+      description: "Create a new user",
+      resolve: (args) =>
+        Effect.sync(() => {
+          const newUser: User = {
+            id: String(users.length + 1),
+            name: args.name,
+            email: args.email,
+          }
+          users.push(newUser)
+          return newUser
+        }),
+    })
+  )
+  .buildSchema()
+
+// =============================================================================
+// GraphQL Router
+// =============================================================================
+
+const graphqlRouter = makeGraphQLRouter(schema, Layer.empty, {
+  path: "/graphql",
+  graphiql: {
+    path: "/graphiql",
+    endpoint: "/graphql",
+  },
+})
+
+// =============================================================================
+// Web Handler
+// =============================================================================
+
+const { handler } = toHandler(graphqlRouter, Layer.empty)
+
+/**
+ * Export for Cloudflare Workers
+ */
+export default {
+  async fetch(request: Request): Promise<Response> {
+    const url = new URL(request.url)
+
+    // Health check
+    if (url.pathname === "/health") {
+      return new Response(JSON.stringify({ status: "ok" }), {
+        headers: { "Content-Type": "application/json" },
+      })
+    }
+
+    return handler(request)
+  },
+}
+
+/**
+ * For local development with Deno or other runtimes, you can use:
+ *
+ * Deno.serve((request) => {
+ *   const url = new URL(request.url)
+ *   if (url.pathname === "/health") {
+ *     return new Response(JSON.stringify({ status: "ok" }), {
+ *       headers: { "Content-Type": "application/json" },
+ *     })
+ *   }
+ *   return handler(request)
+ * })
+ */
+`;
+var generateServerTemplate = (ctx) => {
+  switch (ctx.serverType) {
+    case "node":
+      return generateNodeServer(ctx);
+    case "bun":
+      return generateBunServer(ctx);
+    case "express":
+      return generateExpressServer(ctx);
+    case "web":
+      return generateWebHandler(ctx);
+  }
+};
+
+// src/commands/create/templates/index.ts
+var generateGitignore = () => `# Dependencies
+node_modules/
+
+# Build output
+dist/
+*.tsbuildinfo
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Environment
+.env
+.env.local
+.env.*.local
+
+# Logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# Testing
+coverage/
+`;
+var generateProject = (ctx) => [
+  {
+    path: "package.json",
+    content: generatePackageJson(ctx)
+  },
+  {
+    path: "tsconfig.json",
+    content: generateTsConfig(ctx)
+  },
+  {
+    path: "src/index.ts",
+    content: generateServerTemplate(ctx)
+  },
+  {
+    path: ".gitignore",
+    content: generateGitignore()
+  }
+];
+var fileExists = (filePath) => effect.Effect.sync(() => fs3__namespace.existsSync(filePath));
+var readFile = (filePath) => effect.Effect.try({
+  try: () => fs3__namespace.readFileSync(filePath, "utf-8"),
+  catch: (error) => new Error(`Failed to read ${filePath}: ${error}`)
+});
+var detectPackageManager = (dir) => effect.Effect.gen(function* () {
+  if (yield* fileExists(path2__namespace.join(dir, "pnpm-lock.yaml"))) return "pnpm";
+  if (yield* fileExists(path2__namespace.join(dir, "bun.lockb"))) return "bun";
+  if (yield* fileExists(path2__namespace.join(dir, "yarn.lock"))) return "yarn";
+  return "npm";
+});
+var detectMonorepo = (targetDir) => effect.Effect.gen(function* () {
+  let currentDir = path2__namespace.dirname(path2__namespace.resolve(targetDir));
+  const root = path2__namespace.parse(currentDir).root;
+  while (currentDir !== root) {
+    const pnpmWorkspacePath = path2__namespace.join(currentDir, "pnpm-workspace.yaml");
+    if (yield* fileExists(pnpmWorkspacePath)) {
+      return {
+        isMonorepo: true,
+        packageManager: effect.Option.some("pnpm"),
+        workspacesRoot: effect.Option.some(currentDir)
+      };
+    }
+    const pkgPath = path2__namespace.join(currentDir, "package.json");
+    if (yield* fileExists(pkgPath)) {
+      const content = yield* readFile(pkgPath).pipe(effect.Effect.catchAll(() => effect.Effect.succeed("")));
+      if (content) {
+        try {
+          const pkg = JSON.parse(content);
+          if (pkg.workspaces) {
+            const pm = yield* detectPackageManager(currentDir);
+            return {
+              isMonorepo: true,
+              packageManager: effect.Option.some(pm),
+              workspacesRoot: effect.Option.some(currentDir)
+            };
+          }
+        } catch {
+        }
+      }
+    }
+    const turboPath = path2__namespace.join(currentDir, "turbo.json");
+    if (yield* fileExists(turboPath)) {
+      const pm = yield* detectPackageManager(currentDir);
+      return {
+        isMonorepo: true,
+        packageManager: effect.Option.some(pm),
+        workspacesRoot: effect.Option.some(currentDir)
+      };
+    }
+    currentDir = path2__namespace.dirname(currentDir);
+  }
+  return {
+    isMonorepo: false,
+    packageManager: effect.Option.none(),
+    workspacesRoot: effect.Option.none()
+  };
+});
+var getInstallCommand = (pm) => {
+  switch (pm) {
+    case "npm":
+      return "npm install";
+    case "pnpm":
+      return "pnpm install";
+    case "yarn":
+      return "yarn";
+    case "bun":
+      return "bun install";
+  }
+};
+var getRunPrefix = (pm) => {
+  switch (pm) {
+    case "npm":
+      return "npm run";
+    case "pnpm":
+      return "pnpm";
+    case "yarn":
+      return "yarn";
+    case "bun":
+      return "bun run";
+  }
+};
+
+// src/commands/create/scaffolder.ts
+var validateDirectory = (targetDir) => effect.Effect.try({
+  try: () => {
+    if (fs3__namespace.existsSync(targetDir)) {
+      const files = fs3__namespace.readdirSync(targetDir);
+      if (files.length > 0) {
+        throw new Error(`Directory ${targetDir} is not empty`);
+      }
+    }
+  },
+  catch: (error) => error instanceof Error ? error : new Error(`Failed to validate directory: ${error}`)
+});
+var mkdirp = (dir) => effect.Effect.try({
+  try: () => fs3__namespace.mkdirSync(dir, { recursive: true }),
+  catch: (error) => new Error(`Failed to create directory ${dir}: ${error}`)
+});
+var writeFile = (filePath, content) => effect.Effect.gen(function* () {
+  yield* mkdirp(path2__namespace.dirname(filePath));
+  yield* effect.Effect.try({
+    try: () => fs3__namespace.writeFileSync(filePath, content, "utf-8"),
+    catch: (error) => new Error(`Failed to write ${filePath}: ${error}`)
+  });
+});
+var runCommand = (command, args, cwd) => effect.Effect.async((resume) => {
+  const child = child_process.spawn(command, args, {
+    cwd,
+    stdio: "inherit",
+    shell: true
+  });
+  child.on("close", (code) => {
+    if (code === 0) {
+      resume(effect.Effect.succeed(void 0));
+    } else {
+      resume(effect.Effect.fail(new Error(`Command failed with exit code ${code}`)));
+    }
+  });
+  child.on("error", (error) => {
+    resume(effect.Effect.fail(new Error(`Failed to run command: ${error.message}`)));
+  });
+  return effect.Effect.sync(() => {
+    child.kill();
+  });
+});
+var installDependencies = (targetDir, packageManager) => effect.Effect.gen(function* () {
+  yield* effect.Console.log("");
+  yield* effect.Console.log("Installing dependencies...");
+  const installCmd = getInstallCommand(packageManager);
+  const [cmd, ...args] = installCmd.split(" ");
+  yield* runCommand(cmd, args, targetDir);
+  yield* effect.Console.log("Dependencies installed successfully!");
+});
+var printSuccessMessage = (ctx, targetDir) => effect.Effect.gen(function* () {
+  const relativePath = path2__namespace.relative(process.cwd(), targetDir) || ".";
+  const runPrefix = getRunPrefix(ctx.packageManager);
+  yield* effect.Console.log("");
+  yield* effect.Console.log(`Successfully created ${ctx.name}!`);
+  yield* effect.Console.log("");
+  yield* effect.Console.log("Next steps:");
+  yield* effect.Console.log(`  cd ${relativePath}`);
+  yield* effect.Console.log(`  ${runPrefix} dev`);
+  yield* effect.Console.log("");
+  yield* effect.Console.log("Your GraphQL server will be available at:");
+  yield* effect.Console.log("  http://localhost:4000/graphql");
+  yield* effect.Console.log("  http://localhost:4000/graphiql (playground)");
+  yield* effect.Console.log("");
+});
+var scaffold = (options) => effect.Effect.gen(function* () {
+  const targetDir = effect.pipe(
+    options.directory,
+    effect.Option.map((dir) => path2__namespace.resolve(process.cwd(), dir)),
+    effect.Option.getOrElse(() => path2__namespace.resolve(process.cwd(), options.name))
+  );
+  const monorepoInfo = yield* detectMonorepo(targetDir);
+  const isMonorepo = effect.pipe(
+    options.monorepo,
+    effect.Option.getOrElse(() => monorepoInfo.isMonorepo)
+  );
+  const packageManager = yield* effect.pipe(
+    options.packageManager,
+    effect.Option.orElse(() => monorepoInfo.packageManager),
+    effect.Option.match({
+      onNone: () => detectPackageManager(process.cwd()),
+      onSome: (pm) => effect.Effect.succeed(pm)
+    })
+  );
+  const ctx = {
+    name: options.name,
+    serverType: options.serverType,
+    isMonorepo,
+    packageManager
+  };
+  yield* effect.Console.log("");
+  yield* effect.Console.log(`Creating ${ctx.name} with ${ctx.serverType} server...`);
+  yield* validateDirectory(targetDir);
+  const files = generateProject(ctx);
+  for (const file of files) {
+    const filePath = path2__namespace.join(targetDir, file.path);
+    yield* writeFile(filePath, file.content);
+    yield* effect.Console.log(`  Created ${file.path}`);
+  }
+  if (!options.skipInstall) {
+    yield* installDependencies(targetDir, packageManager).pipe(
+      effect.Effect.catchAll(
+        (error) => effect.Console.log(`Warning: Failed to install dependencies: ${error.message}`).pipe(
+          effect.Effect.andThen(
+            effect.Console.log(
+              "You can install them manually by running: " + getInstallCommand(packageManager)
+            )
+          )
+        )
+      )
+    );
+  } else {
+    yield* effect.Console.log("");
+    yield* effect.Console.log(
+      `Skipping dependency installation. Run '${getInstallCommand(packageManager)}' to install.`
+    );
+  }
+  yield* printSuccessMessage(ctx, targetDir);
+});
+
+// src/commands/create/index.ts
+var printCreateHelp = () => {
+  console.log(`
+Usage: effect-gql create <name> --server-type <type> [options]
+
+Create a new Effect GraphQL project.
+
+Arguments:
+  name                 Package/project name
+
+Required Options:
+  -s, --server-type    Server type: node, bun, express, web
+
+Optional Options:
+  -d, --directory      Target directory (default: ./<name>)
+  --monorepo           Create as workspace package (auto-detected)
+  --skip-install       Skip dependency installation
+  --package-manager    Package manager: npm, pnpm, yarn, bun
+  -i, --interactive    Interactive mode (prompts for options)
+  -h, --help           Show this help message
+
+Server Types:
+  node      Node.js server using @effect-gql/node
+            Best for: General Node.js deployments
+
+  bun       Bun server using @effect-gql/bun
+            Best for: Bun runtime with native WebSocket support
+
+  express   Express middleware using @effect-gql/express
+            Best for: Integrating into existing Express apps
+
+  web       Web standard handler using @effect-gql/web
+            Best for: Cloudflare Workers, Deno, edge runtimes
+
+Examples:
+  effect-gql create my-api --server-type node
+  effect-gql create my-api -s bun
+  effect-gql create my-api -s express -d ./packages/api --monorepo
+  effect-gql create my-api -s web --skip-install
+  effect-gql create --interactive
+`);
+};
+var prompt = (question) => effect.Effect.async((resume) => {
+  const rl = readline__namespace.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  rl.question(question, (answer) => {
+    rl.close();
+    resume(effect.Effect.succeed(answer.trim()));
+  });
+  rl.on("error", (error) => {
+    rl.close();
+    resume(effect.Effect.fail(new Error(`Input error: ${error.message}`)));
+  });
+  return effect.Effect.sync(() => rl.close());
+});
+var selectPrompt = (question, options) => effect.Effect.gen(function* () {
+  yield* effect.Console.log(question);
+  options.forEach((opt, i) => {
+    console.log(`  ${i + 1}) ${opt.label}`);
+  });
+  const answer = yield* prompt("Enter number: ");
+  const index = parseInt(answer, 10) - 1;
+  if (isNaN(index) || index < 0 || index >= options.length) {
+    yield* effect.Console.log(`Invalid selection. Please enter 1-${options.length}.`);
+    return yield* selectPrompt(question, options);
+  }
+  return options[index].value;
+});
+var confirmPrompt = (question, defaultValue) => effect.Effect.gen(function* () {
+  const hint = "[y/N]";
+  const answer = yield* prompt(`${question} ${hint} `);
+  if (answer === "") return defaultValue;
+  const lower = answer.toLowerCase();
+  if (lower === "y" || lower === "yes") return true;
+  if (lower === "n" || lower === "no") return false;
+  yield* effect.Console.log("Please answer 'y' or 'n'.");
+  return yield* confirmPrompt(question, defaultValue);
+});
+var runInteractive = () => effect.Effect.gen(function* () {
+  yield* effect.Console.log("");
+  yield* effect.Console.log("Create a new Effect GraphQL project");
+  yield* effect.Console.log("====================================");
+  yield* effect.Console.log("");
+  const name = yield* prompt("Project name: ");
+  if (!name) {
+    return yield* effect.Effect.fail(new Error("Project name is required"));
+  }
+  if (!/^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/.test(name)) {
+    yield* effect.Console.log("Warning: Name may not be a valid npm package name.");
+  }
+  const serverType = yield* selectPrompt("Select server type:", [
+    { label: "Node.js (@effect-gql/node)", value: "node" },
+    { label: "Bun (@effect-gql/bun)", value: "bun" },
+    { label: "Express (@effect-gql/express)", value: "express" },
+    { label: "Web/Workers (@effect-gql/web)", value: "web" }
+  ]);
+  const monorepo = yield* confirmPrompt("Create as monorepo workspace package?", false);
+  const packageManager = monorepo ? effect.Option.some(
+    yield* selectPrompt("Select package manager:", [
+      { label: "pnpm", value: "pnpm" },
+      { label: "npm", value: "npm" },
+      { label: "yarn", value: "yarn" },
+      { label: "bun", value: "bun" }
+    ])
+  ) : effect.Option.none();
+  return {
+    name,
+    serverType,
+    directory: effect.Option.none(),
+    monorepo: effect.Option.some(monorepo),
+    skipInstall: false,
+    packageManager
+  };
+});
+var runCreate = (args) => effect.Effect.gen(function* () {
+  const parsed = parseArgs2(args);
+  if ("help" in parsed) {
+    printCreateHelp();
+    return;
+  }
+  if ("error" in parsed) {
+    yield* effect.Console.error(`Error: ${parsed.error}`);
+    yield* effect.Console.log("");
+    printCreateHelp();
+    process.exitCode = 1;
+    return;
+  }
+  const options = "interactive" in parsed ? yield* runInteractive() : parsed.options;
+  yield* scaffold(options);
+});
+
 // src/bin.ts
 var VERSION = "0.1.0";
 var printHelp = () => {
@@ -189,7 +1308,7 @@ Usage: effect-gql <command> [options]
 
 Commands:
   generate-schema    Generate GraphQL SDL from a schema module
-  create             Create a new Effect GraphQL project (coming soon)
+  create             Create a new Effect GraphQL project
 
 Options:
   -h, --help         Show this help message
@@ -198,7 +1317,7 @@ Options:
 Examples:
   effect-gql generate-schema ./src/schema.ts
   effect-gql generate-schema ./src/schema.ts -o schema.graphql
-  effect-gql create my-app
+  effect-gql create my-app --server-type node
 
 Run 'effect-gql <command> --help' for command-specific help.
 `);
@@ -223,8 +1342,7 @@ var main = effect.Effect.gen(function* () {
       yield* runGenerateSchema(commandArgs);
       break;
     case "create":
-      yield* effect.Console.log("The 'create' command is coming soon!");
-      yield* effect.Console.log("It will help you scaffold new Effect GraphQL projects.");
+      yield* runCreate(commandArgs);
       break;
     default:
       yield* effect.Console.error(`Unknown command: ${command}`);