create-prisma 0.0.0 → 0.1.4

package/dist/index.d.mts

@@ -0,0 +1,319 @@
+#!/usr/bin/env node
+import * as _orpc_server0 from "@orpc/server";
+import * as trpc_cli0 from "trpc-cli";
+import * as zod from "zod";
+import { z } from "zod";
+import * as zod_v4_core0 from "zod/v4/core";
+
+//#region node_modules/@orpc/client/dist/index.d.mts
+declare const COMMON_ORPC_ERROR_DEFS: {
+  readonly BAD_REQUEST: {
+    readonly status: 400;
+    readonly message: "Bad Request";
+  };
+  readonly UNAUTHORIZED: {
+    readonly status: 401;
+    readonly message: "Unauthorized";
+  };
+  readonly FORBIDDEN: {
+    readonly status: 403;
+    readonly message: "Forbidden";
+  };
+  readonly NOT_FOUND: {
+    readonly status: 404;
+    readonly message: "Not Found";
+  };
+  readonly METHOD_NOT_SUPPORTED: {
+    readonly status: 405;
+    readonly message: "Method Not Supported";
+  };
+  readonly NOT_ACCEPTABLE: {
+    readonly status: 406;
+    readonly message: "Not Acceptable";
+  };
+  readonly TIMEOUT: {
+    readonly status: 408;
+    readonly message: "Request Timeout";
+  };
+  readonly CONFLICT: {
+    readonly status: 409;
+    readonly message: "Conflict";
+  };
+  readonly PRECONDITION_FAILED: {
+    readonly status: 412;
+    readonly message: "Precondition Failed";
+  };
+  readonly PAYLOAD_TOO_LARGE: {
+    readonly status: 413;
+    readonly message: "Payload Too Large";
+  };
+  readonly UNSUPPORTED_MEDIA_TYPE: {
+    readonly status: 415;
+    readonly message: "Unsupported Media Type";
+  };
+  readonly UNPROCESSABLE_CONTENT: {
+    readonly status: 422;
+    readonly message: "Unprocessable Content";
+  };
+  readonly TOO_MANY_REQUESTS: {
+    readonly status: 429;
+    readonly message: "Too Many Requests";
+  };
+  readonly CLIENT_CLOSED_REQUEST: {
+    readonly status: 499;
+    readonly message: "Client Closed Request";
+  };
+  readonly INTERNAL_SERVER_ERROR: {
+    readonly status: 500;
+    readonly message: "Internal Server Error";
+  };
+  readonly NOT_IMPLEMENTED: {
+    readonly status: 501;
+    readonly message: "Not Implemented";
+  };
+  readonly BAD_GATEWAY: {
+    readonly status: 502;
+    readonly message: "Bad Gateway";
+  };
+  readonly SERVICE_UNAVAILABLE: {
+    readonly status: 503;
+    readonly message: "Service Unavailable";
+  };
+  readonly GATEWAY_TIMEOUT: {
+    readonly status: 504;
+    readonly message: "Gateway Timeout";
+  };
+};
+type CommonORPCErrorCode = keyof typeof COMMON_ORPC_ERROR_DEFS;
+type ORPCErrorCode = CommonORPCErrorCode | (string & {});
+//#endregion
+//#region node_modules/@standard-schema/spec/dist/index.d.ts
+/** The Standard Typed interface. This is a base type extended by other specs. */
+interface StandardTypedV1<Input = unknown, Output = Input> {
+  /** The Standard properties. */
+  readonly "~standard": StandardTypedV1.Props<Input, Output>;
+}
+declare namespace StandardTypedV1 {
+  /** The Standard Typed properties interface. */
+  interface Props<Input = unknown, Output = Input> {
+    /** The version number of the standard. */
+    readonly version: 1;
+    /** The vendor name of the schema library. */
+    readonly vendor: string;
+    /** Inferred types associated with the schema. */
+    readonly types?: Types<Input, Output> | undefined;
+  }
+  /** The Standard Typed types interface. */
+  interface Types<Input = unknown, Output = Input> {
+    /** The input type of the schema. */
+    readonly input: Input;
+    /** The output type of the schema. */
+    readonly output: Output;
+  }
+  /** Infers the input type of a Standard Typed. */
+  type InferInput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+  /** Infers the output type of a Standard Typed. */
+  type InferOutput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+}
+/** The Standard Schema interface. */
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+  /** The Standard Schema properties. */
+  readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1 {
+  /** The Standard Schema properties interface. */
+  interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+    /** Validates unknown input values. */
+    readonly validate: (value: unknown, options?: StandardSchemaV1.Options | undefined) => Result<Output> | Promise<Result<Output>>;
+  }
+  /** The result interface of the validate function. */
+  type Result<Output> = SuccessResult<Output> | FailureResult;
+  /** The result interface if validation succeeds. */
+  interface SuccessResult<Output> {
+    /** The typed output value. */
+    readonly value: Output;
+    /** A falsy value for `issues` indicates success. */
+    readonly issues?: undefined;
+  }
+  interface Options {
+    /** Explicit support for additional vendor-specific parameters, if needed. */
+    readonly libraryOptions?: Record<string, unknown> | undefined;
+  }
+  /** The result interface if validation fails. */
+  interface FailureResult {
+    /** The issues of failed validation. */
+    readonly issues: ReadonlyArray<Issue>;
+  }
+  /** The issue interface of the failure output. */
+  interface Issue {
+    /** The error message of the issue. */
+    readonly message: string;
+    /** The path of the issue, if any. */
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+  }
+  /** The path segment interface of the issue. */
+  interface PathSegment {
+    /** The key representing a path segment. */
+    readonly key: PropertyKey;
+  }
+  /** The Standard types interface. */
+  interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {}
+  /** Infers the input type of a Standard. */
+  type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+  /** Infers the output type of a Standard. */
+  type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+}
+/** The Standard JSON Schema interface. */
+//#endregion
+//#region node_modules/@orpc/contract/dist/shared/contract.TuRtB1Ca.d.mts
+type Schema<TInput, TOutput> = StandardSchemaV1<TInput, TOutput>;
+type AnySchema = Schema<any, any>;
+interface ErrorMapItem<TDataSchema extends AnySchema> {
+  status?: number;
+  message?: string;
+  data?: TDataSchema;
+}
+type ErrorMap = { [key in ORPCErrorCode]?: ErrorMapItem<AnySchema> };
+type MergedErrorMap<T1 extends ErrorMap, T2 extends ErrorMap> = Omit<T1, keyof T2> & T2;
+//#endregion
+//#region src/types.d.ts
+declare const DatabaseProviderSchema: z.ZodEnum<{
+  postgresql: "postgresql";
+  mysql: "mysql";
+  sqlite: "sqlite";
+  sqlserver: "sqlserver";
+  cockroachdb: "cockroachdb";
+}>;
+declare const PackageManagerSchema: z.ZodEnum<{
+  npm: "npm";
+  pnpm: "pnpm";
+  bun: "bun";
+}>;
+declare const SchemaPresetSchema: z.ZodEnum<{
+  empty: "empty";
+  basic: "basic";
+}>;
+declare const CreateTemplateSchema: z.ZodEnum<{
+  hono: "hono";
+  next: "next";
+}>;
+declare const DatabaseUrlSchema: z.ZodString;
+declare const InitCommandInputSchema: z.ZodObject<{
+  yes: z.ZodOptional<z.ZodBoolean>;
+  verbose: z.ZodOptional<z.ZodBoolean>;
+  provider: z.ZodOptional<z.ZodEnum<{
+    postgresql: "postgresql";
+    mysql: "mysql";
+    sqlite: "sqlite";
+    sqlserver: "sqlserver";
+    cockroachdb: "cockroachdb";
+  }>>;
+  packageManager: z.ZodOptional<z.ZodEnum<{
+    npm: "npm";
+    pnpm: "pnpm";
+    bun: "bun";
+  }>>;
+  prismaPostgres: z.ZodOptional<z.ZodBoolean>;
+  databaseUrl: z.ZodOptional<z.ZodString>;
+  install: z.ZodOptional<z.ZodBoolean>;
+  generate: z.ZodOptional<z.ZodBoolean>;
+  schemaPreset: z.ZodOptional<z.ZodEnum<{
+    empty: "empty";
+    basic: "basic";
+  }>>;
+}, z.core.$strip>;
+type InitCommandInput = z.infer<typeof InitCommandInputSchema>;
+declare const CreateCommandInputSchema: z.ZodObject<{
+  yes: z.ZodOptional<z.ZodBoolean>;
+  verbose: z.ZodOptional<z.ZodBoolean>;
+  name: z.ZodOptional<z.ZodString>;
+  template: z.ZodOptional<z.ZodEnum<{
+    hono: "hono";
+    next: "next";
+  }>>;
+  force: z.ZodOptional<z.ZodBoolean>;
+  provider: z.ZodOptional<z.ZodEnum<{
+    postgresql: "postgresql";
+    mysql: "mysql";
+    sqlite: "sqlite";
+    sqlserver: "sqlserver";
+    cockroachdb: "cockroachdb";
+  }>>;
+  packageManager: z.ZodOptional<z.ZodEnum<{
+    npm: "npm";
+    pnpm: "pnpm";
+    bun: "bun";
+  }>>;
+  prismaPostgres: z.ZodOptional<z.ZodBoolean>;
+  databaseUrl: z.ZodOptional<z.ZodString>;
+  install: z.ZodOptional<z.ZodBoolean>;
+  generate: z.ZodOptional<z.ZodBoolean>;
+  schemaPreset: z.ZodOptional<z.ZodEnum<{
+    empty: "empty";
+    basic: "basic";
+  }>>;
+}, z.core.$strip>;
+type CreateCommandInput = z.infer<typeof CreateCommandInputSchema>;
+//#endregion
+//#region src/index.d.ts
+declare const router: {
+  create: _orpc_server0.Procedure<_orpc_server0.MergedInitialContext<Record<never, never>, Record<never, never>, Record<never, never>>, Record<never, never>, zod.ZodOptional<zod.ZodObject<{
+    yes: zod.ZodOptional<zod.ZodBoolean>;
+    verbose: zod.ZodOptional<zod.ZodBoolean>;
+    name: zod.ZodOptional<zod.ZodString>;
+    template: zod.ZodOptional<zod.ZodEnum<{
+      hono: "hono";
+      next: "next";
+    }>>;
+    force: zod.ZodOptional<zod.ZodBoolean>;
+    provider: zod.ZodOptional<zod.ZodEnum<{
+      postgresql: "postgresql";
+      mysql: "mysql";
+      sqlite: "sqlite";
+      sqlserver: "sqlserver";
+      cockroachdb: "cockroachdb";
+    }>>;
+    packageManager: zod.ZodOptional<zod.ZodEnum<{
+      npm: "npm";
+      pnpm: "pnpm";
+      bun: "bun";
+    }>>;
+    prismaPostgres: zod.ZodOptional<zod.ZodBoolean>;
+    databaseUrl: zod.ZodOptional<zod.ZodString>;
+    install: zod.ZodOptional<zod.ZodBoolean>;
+    generate: zod.ZodOptional<zod.ZodBoolean>;
+    schemaPreset: zod.ZodOptional<zod.ZodEnum<{
+      empty: "empty";
+      basic: "basic";
+    }>>;
+  }, zod_v4_core0.$strip>>, Schema<void, void>, MergedErrorMap<Record<never, never>, Record<never, never>>, Record<never, never>>;
+  init: _orpc_server0.Procedure<_orpc_server0.MergedInitialContext<Record<never, never>, Record<never, never>, Record<never, never>>, Record<never, never>, zod.ZodOptional<zod.ZodObject<{
+    yes: zod.ZodOptional<zod.ZodBoolean>;
+    verbose: zod.ZodOptional<zod.ZodBoolean>;
+    provider: zod.ZodOptional<zod.ZodEnum<{
+      postgresql: "postgresql";
+      mysql: "mysql";
+      sqlite: "sqlite";
+      sqlserver: "sqlserver";
+      cockroachdb: "cockroachdb";
+    }>>;
+    packageManager: zod.ZodOptional<zod.ZodEnum<{
+      npm: "npm";
+      pnpm: "pnpm";
+      bun: "bun";
+    }>>;
+    prismaPostgres: zod.ZodOptional<zod.ZodBoolean>;
+    databaseUrl: zod.ZodOptional<zod.ZodString>;
+    install: zod.ZodOptional<zod.ZodBoolean>;
+    generate: zod.ZodOptional<zod.ZodBoolean>;
+    schemaPreset: zod.ZodOptional<zod.ZodEnum<{
+      empty: "empty";
+      basic: "basic";
+    }>>;
+  }, zod_v4_core0.$strip>>, Schema<void, void>, MergedErrorMap<Record<never, never>, Record<never, never>>, Record<never, never>>;
+};
+declare function createCreatePrismaCli(): trpc_cli0.TrpcCli;
+declare function init(input?: InitCommandInput): Promise<void>;
+declare function create(input?: CreateCommandInput): Promise<void>;
+//#endregion
+export { type CreateCommandInput, CreateCommandInputSchema, CreateTemplateSchema, DatabaseProviderSchema, DatabaseUrlSchema, type InitCommandInput, InitCommandInputSchema, PackageManagerSchema, SchemaPresetSchema, create, createCreatePrismaCli, init, router };

package/dist/index.mjs

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+import { a as DatabaseProviderSchema, c as PackageManagerSchema, i as CreateTemplateSchema, l as SchemaPresetSchema, n as runInitCommand, o as DatabaseUrlSchema, r as CreateCommandInputSchema, s as InitCommandInputSchema, t as runCreateCommand } from "./create-Dz9GFGFQ.mjs";
+import { os } from "@orpc/server";
+import { createCli } from "trpc-cli";
+
+//#region src/index.ts
+const CLI_VERSION = "0.1.4";
+const router = os.router({
+	create: os.meta({
+		description: "Create a new project with Prisma setup",
+		default: true,
+		negateBooleans: true
+	}).input(CreateCommandInputSchema.optional()).handler(async ({ input }) => {
+		await runCreateCommand(input ?? {});
+	}),
+	init: os.meta({
+		description: "Initialize Prisma in your current project",
+		negateBooleans: true
+	}).input(InitCommandInputSchema.optional()).handler(async ({ input }) => {
+		await runInitCommand(input ?? {});
+	})
+});
+function createCreatePrismaCli() {
+	return createCli({
+		router,
+		name: "create-prisma",
+		version: CLI_VERSION
+	});
+}
+async function init(input = {}) {
+	await runInitCommand(input);
+}
+async function create(input = {}) {
+	await runCreateCommand(input);
+}
+
+//#endregion
+export { CreateCommandInputSchema, CreateTemplateSchema, DatabaseProviderSchema, DatabaseUrlSchema, InitCommandInputSchema, PackageManagerSchema, SchemaPresetSchema, create, createCreatePrismaCli, init, router };

package/package.json

@@ -1,6 +1,66 @@
 {
   "name": "create-prisma",
-  "version": "0.0.0",
-  "main": "index.js",
-  "license": "MIT"
+  "version": "0.1.4",
+  "description": "Create and initialize Prisma 7 projects with first-party templates and great DX.",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/prisma/create-prisma"
+  },
+  "homepage": "https://github.com/prisma/create-prisma",
+  "bugs": {
+    "url": "https://github.com/prisma/create-prisma/issues"
+  },
+  "private": false,
+  "type": "module",
+  "bin": {
+    "create-prisma": "dist/cli.mjs"
+  },
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    },
+    "./cli": {
+      "import": "./dist/cli.mjs"
+    }
+  },
+  "files": [
+    "dist",
+    "templates",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "engines": {
+    "node": ">=18.0.0",
+    "bun": ">=1.3.0"
+  },
+  "packageManager": "bun@1.3.9",
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "start": "bun run ./dist/cli.mjs",
+    "typecheck": "tsc --noEmit",
+    "bump": "bun run scripts/bump-version.ts",
+    "release": "bun run bump",
+    "release-notes": "bunx changelogithub"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.0.1",
+    "@orpc/server": "^1.13.5",
+    "execa": "^9.6.1",
+    "fs-extra": "^11.3.3",
+    "handlebars": "^4.7.8",
+    "trpc-cli": "^0.12.4",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.9",
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^25.3.0",
+    "changelogithub": "^14.0.0",
+    "tsdown": "^0.20.3",
+    "typescript": "^5.9.3"
+  }
 }

package/templates/create/hono/README.md.hbs

@@ -0,0 +1,66 @@
+# {{projectName}}
+
+Generated by `create-prisma` with the Hono template.
+
+## Scripts
+
+{{#if (eq packageManager "bun")}}
+- `bun run dev` - start local dev server
+- `bun run build` - typecheck and compile
+- `bun run start` - run compiled server from `dist/`
+{{else}}
+{{#if (eq packageManager "pnpm")}}
+- `pnpm dev` - start local dev server
+- `pnpm build` - typecheck and compile
+- `pnpm start` - run compiled server from `dist/`
+{{else}}
+{{#if (eq packageManager "npm")}}
+- `npm run dev` - start local dev server
+- `npm run build` - typecheck and compile
+- `npm run start` - run compiled server from `dist/`
+{{else}}
+- `npm run dev` or `pnpm dev` or `bun run dev` - start local dev server
+- `npm run build` or `pnpm build` or `bun run build` - typecheck and compile
+- `npm run start` or `pnpm start` or `bun run start` - run compiled server from `dist/`
+{{/if}}
+{{/if}}
+{{/if}}
+
+## Prisma
+
+1. Make sure dependencies are installed.
+2. Generate Prisma Client:
+
+{{#if (eq packageManager "bun")}}
+`bun run db:generate`
+{{else}}
+{{#if (eq packageManager "pnpm")}}
+`pnpm db:generate`
+{{else}}
+{{#if (eq packageManager "npm")}}
+`npm run db:generate`
+{{else}}
+`npm run db:generate` or `pnpm db:generate` or `bun run db:generate`
+{{/if}}
+{{/if}}
+{{/if}}
+
+3. Run your first migration:
+
+{{#if (eq packageManager "bun")}}
+`bun run db:migrate`
+{{else}}
+{{#if (eq packageManager "pnpm")}}
+`pnpm db:migrate`
+{{else}}
+{{#if (eq packageManager "npm")}}
+`npm run db:migrate`
+{{else}}
+`npm run db:migrate` or `pnpm db:migrate` or `bun run db:migrate`
+{{/if}}
+{{/if}}
+{{/if}}
+{{#if (eq schemaPreset "basic")}}
+
+The template includes a basic `User` model and a sample `GET /users` endpoint.
+{{/if}}

package/templates/create/hono/package.json.hbs

@@ -0,0 +1,19 @@
+{
+  "name": "{{projectName}}",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "tsx watch src/index.ts",
+    "build": "tsc",
+    "start": "tsx dist/src/index.js"
+  },
+  "dependencies": {
+    "@hono/node-server": "^1.19.9",
+    "hono": "^4.12.2"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.17",
+    "tsx": "^4.7.1",
+    "typescript": "^5.8.3"
+  }
+}

package/templates/create/hono/src/index.ts.hbs

@@ -0,0 +1,34 @@
+import { serve } from "@hono/node-server";
+import { Hono } from "hono";
+{{#if (eq schemaPreset "basic")}}
+import { prisma } from "../prisma";
+{{/if}}
+
+const app = new Hono();
+
+app.get("/", (c) => {
+  return c.json({
+    message: "hello from create-prisma + hono",
+  });
+});
+{{#if (eq schemaPreset "basic")}}
+
+app.get("/users", async (c) => {
+  const users = await prisma.user.findMany({
+    take: 10,
+    orderBy: {
+      createdAt: "desc",
+    },
+  });
+
+  return c.json(users);
+});
+{{/if}}
+
+const port = 3000;
+serve({
+  fetch: app.fetch,
+  port,
+});
+
+console.log(`Server running at http://localhost:${port}`);

package/templates/create/hono/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "verbatimModuleSyntax": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "outDir": "dist",
+    "rootDir": "."
+  },
+  "include": ["src/**/*.ts", "prisma/**/*.ts", "prisma.config.ts"]
+}

package/templates/create/next/README.md.hbs

@@ -0,0 +1,45 @@
+# {{projectName}}
+
+Generated by `create-prisma` with the Next.js template.
+
+## Scripts
+
+{{#if (eq packageManager "bun")}}
+- `bun dev` - start local dev server
+- `bun run build` - production build
+- `bun run start` - run production server
+{{else}}
+{{#if (eq packageManager "pnpm")}}
+- `pnpm dev` - start local dev server
+- `pnpm build` - production build
+- `pnpm start` - run production server
+{{else}}
+{{#if (eq packageManager "npm")}}
+- `npm run dev` - start local dev server
+- `npm run build` - production build
+- `npm run start` - run production server
+{{else}}
+- `npm run dev` or `pnpm dev` or `bun dev` - start local dev server
+- `npm run build` or `pnpm build` or `bun run build` - production build
+- `npm run start` or `pnpm start` or `bun run start` - run production server
+{{/if}}
+{{/if}}
+{{/if}}
+
+## Prisma
+
+Prisma setup is scaffolded automatically in:
+
+- `prisma/schema.prisma`
+- `prisma/index.ts`
+- `prisma.config.ts`
+
+Database helper scripts are added to `package.json`:
+
+- `db:generate`
+- `db:push`
+- `db:migrate`
+{{#if (eq schemaPreset "basic")}}
+
+The starter page reads from a basic `User` model so you can verify queries quickly.
+{{/if}}

package/templates/create/next/app/globals.css

@@ -0,0 +1,47 @@
+:root {
+  color-scheme: dark;
+}
+
+* {
+  box-sizing: border-box;
+}
+
+body {
+  margin: 0;
+  font-family: "Geist", ui-sans-serif, system-ui, -apple-system, Segoe UI, sans-serif;
+  background: #0b0d10;
+  color: #e8edf2;
+}
+
+main {
+  width: min(860px, 100%);
+  margin: 0 auto;
+  padding: 4rem 1.25rem;
+}
+
+h1 {
+  margin: 0;
+  font-size: clamp(1.9rem, 4vw, 2.8rem);
+  letter-spacing: -0.02em;
+}
+
+h2 {
+  margin-top: 2rem;
+}
+
+p,
+li {
+  line-height: 1.65;
+  color: #c7ced8;
+}
+
+ul {
+  padding-left: 1.15rem;
+}
+
+code {
+  padding: 0.12rem 0.4rem;
+  border-radius: 6px;
+  background: #171b21;
+  color: #dbe5f4;
+}

package/templates/create/next/app/layout.tsx.hbs

@@ -0,0 +1,19 @@
+import type { Metadata } from "next";
+import "./globals.css";
+
+export const metadata: Metadata = {
+  title: "{{projectName}}",
+  description: "Generated by create-prisma",
+};
+
+export default function RootLayout({
+  children,
+}: Readonly<{
+  children: React.ReactNode;
+}>) {
+  return (
+    <html lang="en">
+      <body>{children}</body>
+    </html>
+  );
+}