create-prisma 0.11.2 → 0.11.3

package/dist/index.mjs

@@ -1,38 +1,74 @@
 #!/usr/bin/env node
-import { a as DatabaseProviderSchema, i as CreateTemplateSchema, n as AuthoringStyleSchema, o as PackageManagerSchema, r as CreateCommandInputSchema, s as CREATE_PRISMA_RESULT_SCHEMA_VERSION, t as runCreateCommand } from "./create-TR_gtjND.mjs";
-import { os } from "@orpc/server";
-import { createCli } from "trpc-cli";
-import { z } from "zod";
+import { _ as databaseProviderInputs, c as CreateCommandResultSchema, d as CreateCommandInputSchema, f as CreateTemplateSchema, g as createTemplates, h as authoringStyles, i as getErrorMessage, l as createCommandFailureResult, m as PackageManagerSchema, n as writeJsonResult, o as applicationRuntime, p as DatabaseProviderSchema, r as runCreateCommandEffect, s as CREATE_PRISMA_RESULT_SCHEMA_VERSION, t as isJsonOutputRequested, u as AuthoringStyleSchema, v as normalizeDatabaseProvider, y as packageManagers } from "./json-output-DzDD1nb9.mjs";
+import { Console, Effect, Option } from "effect";
+import { Argument, CliError, Command, Flag } from "effect/unstable/cli";
 
 //#region src/index.ts
-const CLI_VERSION = "0.11.2";
-const CreateCliInputSchema = z.tuple([z.string().trim().min(1, "Please enter a valid project name").optional().describe("Project name / directory"), CreateCommandInputSchema]);
-function normalizeCreateCliInput(input) {
-	const [projectName, options] = input;
-	return {
-		...options,
-		name: options.name ?? projectName
+const CLI_VERSION = "0.11.3";
+const optionalArgument = (name, description) => Argument.string(name).pipe(Argument.withDescription(description), Argument.optional, Argument.map(Option.getOrUndefined));
+const optionalBoolean = (name, description) => Flag.boolean(name).pipe(Flag.withDescription(description), Flag.optional, Flag.map(Option.getOrUndefined));
+const optionalString = (name, description) => Flag.string(name).pipe(Flag.withDescription(description), Flag.optional, Flag.map(Option.getOrUndefined));
+const createPrismaCommand = Command.make("create-prisma", {
+	projectName: optionalArgument("project-name", "Project name / directory"),
+	name: optionalString("name", "Project name / directory"),
+	template: Flag.choice("template", createTemplates).pipe(Flag.withDescription("Project template"), Flag.optional, Flag.map(Option.getOrUndefined)),
+	provider: Flag.choice("provider", databaseProviderInputs).pipe(Flag.withDescription("Database provider"), Flag.optional, Flag.map(Option.map(normalizeDatabaseProvider)), Flag.map(Option.getOrUndefined)),
+	authoring: Flag.choice("authoring", authoringStyles).pipe(Flag.withDescription("Contract authoring style"), Flag.optional, Flag.map(Option.getOrUndefined)),
+	packageManager: Flag.choice("package-manager", packageManagers).pipe(Flag.withDescription("Package manager used for dependency installation"), Flag.optional, Flag.map(Option.getOrUndefined)),
+	deploy: optionalBoolean("deploy", "Deploy the generated app to Prisma immediately"),
+	workspace: optionalString("workspace", "Prisma workspace id or name to deploy into"),
+	force: optionalBoolean("force", "Allow scaffolding into a non-empty target directory"),
+	yes: optionalBoolean("yes", "Skip prompts and accept default choices"),
+	verbose: optionalBoolean("verbose", "Show verbose command output during setup"),
+	json: optionalBoolean("json", "Emit one quiet JSON result for agents and automation (non-interactive; deploys unless --no-deploy)")
+}, Effect.fn("Cli.create")(function* (options) {
+	const input = {
+		...options.name ?? options.projectName ? { name: options.name ?? options.projectName } : {},
+		...options.template ? { template: options.template } : {},
+		...options.provider ? { provider: options.provider } : {},
+		...options.authoring ? { authoring: options.authoring } : {},
+		...options.packageManager ? { packageManager: options.packageManager } : {},
+		...options.deploy !== void 0 ? { deploy: options.deploy } : {},
+		...options.workspace ? { workspace: options.workspace } : {},
+		...options.force !== void 0 ? { force: options.force } : {},
+		...options.yes !== void 0 ? { yes: options.yes } : {},
+		...options.verbose !== void 0 ? { verbose: options.verbose } : {},
+		...options.json !== void 0 ? { json: options.json } : {}
 	};
-}
-const router = os.router({ create: os.meta({
-	description: "Create a new project with Prisma setup",
-	default: true,
-	negateBooleans: true
-}).input(CreateCliInputSchema).handler(async ({ input }) => {
-	const createInput = normalizeCreateCliInput(input);
-	const result = await runCreateCommand(createInput);
-	return createInput.json ? result : void 0;
-}) });
+	const result = yield* runCreateCommandEffect(input);
+	if (input.json) yield* writeJsonResult(result);
+	if (!result.ok) yield* Effect.sync(() => void (process.exitCode = 1));
+})).pipe(Command.withDescription("Create a new project with Prisma setup"), Command.withExamples([{
+	command: "create-prisma my-app",
+	description: "Create a project interactively"
+}, {
+	command: "create-prisma my-app --yes --json",
+	description: "Create and deploy with machine-readable output"
+}]));
+const silentConsole = Object.assign(Object.create(console), {
+	log() {},
+	error() {}
+});
 function createCreatePrismaCli() {
-	return createCli({
-		router,
-		name: "create-prisma",
-		version: CLI_VERSION
-	});
+	return createPrismaCommand;
+}
+function runCreatePrismaCli(argv = process.argv.slice(2)) {
+	const json = isJsonOutputRequested(argv);
+	const args = argv[0] === "create" ? argv.slice(1) : argv;
+	let program = Command.runWith(createPrismaCommand, {
+		version: CLI_VERSION,
+		renderErrors: !json
+	})(args).pipe(Effect.catch((error) => Effect.gen(function* () {
+		if (error instanceof CliError.ShowHelp && error.errors.length === 0) return;
+		process.exitCode = 1;
+		if (json) yield* writeJsonResult(createCommandFailureResult("parse_arguments", error instanceof CliError.ShowHelp ? error.errors.map((item) => item.message).join("; ") : getErrorMessage(error)));
+	})));
+	if (json) program = Effect.provideService(program, Console.Console, silentConsole);
+	return program;
 }
-async function create(input = {}) {
-	await runCreateCommand(input);
+function create(input = {}) {
+	return applicationRuntime.runPromise(runCreateCommandEffect(input).pipe(Effect.asVoid));
 }
 
 //#endregion
-export { AuthoringStyleSchema, CREATE_PRISMA_RESULT_SCHEMA_VERSION, CreateCommandInputSchema, CreateTemplateSchema, DatabaseProviderSchema, PackageManagerSchema, create, createCreatePrismaCli, router };
+export { AuthoringStyleSchema, CREATE_PRISMA_RESULT_SCHEMA_VERSION, CreateCommandInputSchema, CreateCommandResultSchema, CreateTemplateSchema, DatabaseProviderSchema, PackageManagerSchema, create, createCreatePrismaCli, createPrismaCommand, runCreatePrismaCli };