@effect-gql/cli 0.1.0 → 1.0.0

package/dist/index.d.ts

@@ -1,29 +0,0 @@
-/**
- * @effect-gql/cli - CLI tools for Effect GraphQL development
- *
- * @example CLI usage
- * ```bash
- * # Generate SDL from schema
- * effect-gql generate-schema ./src/schema.ts
- * effect-gql generate-schema ./src/schema.ts -o schema.graphql
- *
- * # Watch mode
- * effect-gql generate-schema ./src/schema.ts -o schema.graphql --watch
- * ```
- *
- * @example Programmatic usage
- * ```typescript
- * import { generateSDL, generateSDLFromModule } from "@effect-gql/cli"
- * import { Effect } from "effect"
- *
- * // From a schema directly
- * const sdl = generateSDL(builder.buildSchema())
- *
- * // From a module path
- * const sdl = await Effect.runPromise(
- *   generateSDLFromModule("./src/schema.ts")
- * )
- * ```
- */
-export { generateSDL, generateSDLFromModule, loadSchema, } from "./commands/generate-schema";
-//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,EACL,WAAW,EACX,qBAAqB,EACrB,UAAU,GACX,MAAM,4BAA4B,CAAA"}

package/dist/index.js

@@ -1,35 +0,0 @@
-"use strict";
-/**
- * @effect-gql/cli - CLI tools for Effect GraphQL development
- *
- * @example CLI usage
- * ```bash
- * # Generate SDL from schema
- * effect-gql generate-schema ./src/schema.ts
- * effect-gql generate-schema ./src/schema.ts -o schema.graphql
- *
- * # Watch mode
- * effect-gql generate-schema ./src/schema.ts -o schema.graphql --watch
- * ```
- *
- * @example Programmatic usage
- * ```typescript
- * import { generateSDL, generateSDLFromModule } from "@effect-gql/cli"
- * import { Effect } from "effect"
- *
- * // From a schema directly
- * const sdl = generateSDL(builder.buildSchema())
- *
- * // From a module path
- * const sdl = await Effect.runPromise(
- *   generateSDLFromModule("./src/schema.ts")
- * )
- * ```
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadSchema = exports.generateSDLFromModule = exports.generateSDL = void 0;
-var generate_schema_1 = require("./commands/generate-schema");
-Object.defineProperty(exports, "generateSDL", { enumerable: true, get: function () { return generate_schema_1.generateSDL; } });
-Object.defineProperty(exports, "generateSDLFromModule", { enumerable: true, get: function () { return generate_schema_1.generateSDLFromModule; } });
-Object.defineProperty(exports, "loadSchema", { enumerable: true, get: function () { return generate_schema_1.loadSchema; } });
-//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;;;AAEH,8DAImC;AAHjC,8GAAA,WAAW,OAAA;AACX,wHAAA,qBAAqB,OAAA;AACrB,6GAAA,UAAU,OAAA"}

package/src/bin.ts

@@ -1,90 +0,0 @@
-#!/usr/bin/env node
-/**
- * Effect GraphQL CLI
- *
- * Usage:
- *   effect-gql <command> [options]
- *
- * Commands:
- *   generate-schema  Generate GraphQL SDL from a schema module
- *   create           Create a new Effect GraphQL project (coming soon)
- */
-
-import { Effect, Console } from "effect"
-import { runGenerateSchema } from "./commands/generate-schema"
-
-const VERSION = "0.1.0"
-
-const printHelp = (): void => {
-  console.log(`
-Effect GraphQL CLI v${VERSION}
-
-Usage: effect-gql <command> [options]
-
-Commands:
-  generate-schema    Generate GraphQL SDL from a schema module
-  create             Create a new Effect GraphQL project (coming soon)
-
-Options:
-  -h, --help         Show this help message
-  -v, --version      Show version number
-
-Examples:
-  effect-gql generate-schema ./src/schema.ts
-  effect-gql generate-schema ./src/schema.ts -o schema.graphql
-  effect-gql create my-app
-
-Run 'effect-gql <command> --help' for command-specific help.
-`)
-}
-
-const printVersion = (): void => {
-  console.log(`effect-gql v${VERSION}`)
-}
-
-const main = Effect.gen(function* () {
-  const args = process.argv.slice(2)
-
-  if (args.length === 0 || args[0] === "-h" || args[0] === "--help") {
-    printHelp()
-    return
-  }
-
-  if (args[0] === "-v" || args[0] === "--version") {
-    printVersion()
-    return
-  }
-
-  const command = args[0]
-  const commandArgs = args.slice(1)
-
-  switch (command) {
-    case "generate-schema":
-      yield* runGenerateSchema(commandArgs)
-      break
-
-    case "create":
-      yield* Console.log("The 'create' command is coming soon!")
-      yield* Console.log("It will help you scaffold new Effect GraphQL projects.")
-      break
-
-    default:
-      yield* Console.error(`Unknown command: ${command}`)
-      printHelp()
-      process.exitCode = 1
-  }
-})
-
-Effect.runPromise(
-  main.pipe(
-    Effect.catchAll((error) =>
-      Console.error(`Error: ${error.message}`).pipe(
-        Effect.andThen(
-          Effect.sync(() => {
-            process.exitCode = 1
-          })
-        )
-      )
-    )
-  )
-)

package/src/commands/generate-schema.ts

@@ -1,240 +0,0 @@
-/**
- * Generate GraphQL SDL from an effect-gql schema builder.
- *
- * Usage:
- *   effect-gql generate-schema <module-path> [options]
- *
- * The module should export one of:
- *   - `builder` - A GraphQLSchemaBuilder instance
- *   - `schema` - A GraphQLSchema instance
- *   - `default` - Either of the above as default export
- */
-
-import { Effect, Console } from "effect"
-import { printSchema, lexicographicSortSchema } from "@effect-gql/core"
-import type { GraphQLSchema } from "graphql"
-import * as fs from "fs"
-import * as path from "path"
-
-interface GenerateOptions {
-  /** Path to the schema module */
-  modulePath: string
-  /** Output file path (stdout if not specified) */
-  output?: string
-  /** Sort schema alphabetically */
-  sort?: boolean
-  /** Watch for changes */
-  watch?: boolean
-}
-
-/**
- * Load a schema from a module path.
- * Supports both GraphQLSchemaBuilder and GraphQLSchema exports.
- */
-export const loadSchema = (modulePath: string): Effect.Effect<GraphQLSchema, Error> =>
-  Effect.gen(function* () {
-    const absolutePath = path.resolve(process.cwd(), modulePath)
-
-    // Validate file exists
-    if (!fs.existsSync(absolutePath)) {
-      return yield* Effect.fail(new Error(`File not found: ${absolutePath}`))
-    }
-
-    // Dynamic import (works with both ESM and CJS via tsx/ts-node)
-    const module = yield* Effect.tryPromise({
-      try: async () => {
-        // Clear require cache for watch mode
-        const resolved = require.resolve(absolutePath)
-        delete require.cache[resolved]
-
-        // Try dynamic import first (ESM), fall back to require (CJS)
-        try {
-          return await import(absolutePath)
-        } catch {
-          return require(absolutePath)
-        }
-      },
-      catch: (error) => new Error(`Failed to load module: ${error}`),
-    })
-
-    // Look for builder or schema export
-    const exported = module.builder ?? module.schema ?? module.default
-
-    if (!exported) {
-      return yield* Effect.fail(
-        new Error(
-          `Module must export 'builder' (GraphQLSchemaBuilder), 'schema' (GraphQLSchema), or a default export`
-        )
-      )
-    }
-
-    // If it's a builder, call buildSchema()
-    if (typeof exported.buildSchema === "function") {
-      return exported.buildSchema() as GraphQLSchema
-    }
-
-    // If it's already a GraphQLSchema
-    if (exported.getQueryType && exported.getTypeMap) {
-      return exported as GraphQLSchema
-    }
-
-    return yield* Effect.fail(
-      new Error(`Export is not a GraphQLSchemaBuilder or GraphQLSchema. Got: ${typeof exported}`)
-    )
-  })
-
-/**
- * Generate SDL from a schema
- */
-export const generateSDL = (schema: GraphQLSchema, options: { sort?: boolean } = {}): string => {
-  const finalSchema = options.sort !== false ? lexicographicSortSchema(schema) : schema
-  return printSchema(finalSchema)
-}
-
-/**
- * Generate SDL from a module path
- */
-export const generateSDLFromModule = (
-  modulePath: string,
-  options: { sort?: boolean } = {}
-): Effect.Effect<string, Error> =>
-  loadSchema(modulePath).pipe(Effect.map((schema) => generateSDL(schema, options)))
-
-/**
- * Run the generate-schema command
- */
-const run = (options: GenerateOptions): Effect.Effect<void, Error> =>
-  Effect.gen(function* () {
-    const schema = yield* loadSchema(options.modulePath)
-    const sdl = generateSDL(schema, { sort: options.sort })
-
-    if (options.output) {
-      const outputPath = path.resolve(process.cwd(), options.output)
-      fs.writeFileSync(outputPath, sdl)
-      yield* Console.log(`Schema written to ${outputPath}`)
-    } else {
-      yield* Console.log(sdl)
-    }
-  })
-
-/**
- * Watch mode - regenerate on file changes
- */
-const watch = (options: GenerateOptions): Effect.Effect<void, Error> =>
-  Effect.gen(function* () {
-    const absolutePath = path.resolve(process.cwd(), options.modulePath)
-    const dir = path.dirname(absolutePath)
-
-    yield* Console.log(`Watching for changes in ${dir}...`)
-
-    // Initial generation
-    yield* run(options).pipe(Effect.catchAll((error) => Console.error(`Error: ${error.message}`)))
-
-    // Watch for changes
-    yield* Effect.async<void, Error>(() => {
-      const watcher = fs.watch(dir, { recursive: true }, (_, filename) => {
-        if (filename?.endsWith(".ts") || filename?.endsWith(".js")) {
-          Effect.runPromise(
-            run(options).pipe(
-              Effect.tap(() => Console.log(`\nRegenerated at ${new Date().toLocaleTimeString()}`)),
-              Effect.catchAll((error) => Console.error(`Error: ${error.message}`))
-            )
-          )
-        }
-      })
-
-      return Effect.sync(() => watcher.close())
-    })
-  })
-
-/**
- * Parse CLI arguments for generate-schema command
- */
-const parseArgs = (args: string[]): GenerateOptions | { help: true } | { error: string } => {
-  const positional: string[] = []
-  let output: string | undefined
-  let sort = true
-  let watchMode = false
-
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i]
-
-    if (arg === "-h" || arg === "--help") {
-      return { help: true }
-    } else if (arg === "-o" || arg === "--output") {
-      output = args[++i]
-    } else if (arg === "--no-sort") {
-      sort = false
-    } else if (arg === "-w" || arg === "--watch") {
-      watchMode = true
-    } else if (!arg.startsWith("-")) {
-      positional.push(arg)
-    } else {
-      return { error: `Unknown option: ${arg}` }
-    }
-  }
-
-  if (positional.length === 0) {
-    return { error: "Missing module path" }
-  }
-
-  return {
-    modulePath: positional[0],
-    output,
-    sort,
-    watch: watchMode,
-  }
-}
-
-export const printGenerateSchemaHelp = (): void => {
-  console.log(`
-Usage: effect-gql generate-schema <module-path> [options]
-
-Generate GraphQL SDL from an effect-gql schema builder.
-
-Arguments:
-  module-path    Path to the schema module (.ts or .js)
-
-Options:
-  -o, --output   Write SDL to file instead of stdout
-  --no-sort      Don't sort schema alphabetically
-  -w, --watch    Watch for changes and regenerate
-  -h, --help     Show this help message
-
-Examples:
-  effect-gql generate-schema ./src/schema.ts
-  effect-gql generate-schema ./src/schema.ts -o schema.graphql
-  effect-gql generate-schema ./src/schema.ts --watch -o schema.graphql
-
-The module should export one of:
-  - builder: A GraphQLSchemaBuilder instance
-  - schema: A GraphQLSchema instance
-  - default: Either of the above as default export
-`)
-}
-
-/**
- * Entry point for the generate-schema command
- */
-export const runGenerateSchema = (args: string[]): Effect.Effect<void, Error> =>
-  Effect.gen(function* () {
-    const parsed = parseArgs(args)
-
-    if ("help" in parsed) {
-      printGenerateSchemaHelp()
-      return
-    }
-
-    if ("error" in parsed) {
-      yield* Console.error(`Error: ${parsed.error}`)
-      printGenerateSchemaHelp()
-      process.exitCode = 1
-      return
-    }
-
-    if (parsed.watch) {
-      yield* watch(parsed)
-    } else {
-      yield* run(parsed)
-    }
-  })

package/src/index.ts

@@ -1,29 +0,0 @@
-/**
- * @effect-gql/cli - CLI tools for Effect GraphQL development
- *
- * @example CLI usage
- * ```bash
- * # Generate SDL from schema
- * effect-gql generate-schema ./src/schema.ts
- * effect-gql generate-schema ./src/schema.ts -o schema.graphql
- *
- * # Watch mode
- * effect-gql generate-schema ./src/schema.ts -o schema.graphql --watch
- * ```
- *
- * @example Programmatic usage
- * ```typescript
- * import { generateSDL, generateSDLFromModule } from "@effect-gql/cli"
- * import { Effect } from "effect"
- *
- * // From a schema directly
- * const sdl = generateSDL(builder.buildSchema())
- *
- * // From a module path
- * const sdl = await Effect.runPromise(
- *   generateSDLFromModule("./src/schema.ts")
- * )
- * ```
- */
-
-export { generateSDL, generateSDLFromModule, loadSchema } from "./commands/generate-schema"