create-baeta 2.0.0-next.2 → 2.0.0-next.8

package/dist/handler-DJjeIx4h.js

@@ -0,0 +1,832 @@
+import { logger } from "@docusaurus/logger";
+import path from "node:path";
+import shell from "shelljs";
+import supportsColor from "supports-color";
+import fs from "fs-extra";
+import prompts from "prompts";
+
+//#region lib/constants.ts
+const defaultPackageManager = "npm";
+const lockfileNames = {
+	npm: "package-lock.json",
+	yarn: "yarn.lock",
+	pnpm: "pnpm-lock.yaml",
+	bun: "bun.lockb"
+};
+const packageManagers = Object.keys(lockfileNames);
+const runtimes = [
+	"node",
+	"deno",
+	"bun"
+];
+const defaultJavaScriptRuntime = "node";
+const templates = ["yoga", "apollo"];
+
+//#endregion
+//#region lib/app-name.ts
+async function getAppName(reqName, rootDir) {
+	async function validateAppName(appName) {
+		if (!appName) return "An app name is required.";
+		const dest = path.resolve(rootDir, appName);
+		if (await fs.pathExists(dest)) return logger.interpolate`Directory already exists at path=${dest}!`;
+		return true;
+	}
+	if (reqName) {
+		const res = await validateAppName(reqName);
+		if (typeof res === "string") throw new TypeError(res);
+		return reqName;
+	}
+	return prompts({
+		type: "text",
+		name: "appName",
+		message: "What should we name this app?",
+		initial: "baeta-app",
+		validate: validateAppName
+	}, { onCancel() {
+		logger.error("An app name is required.");
+		process.exit(1);
+	} }).then((result) => result.appName);
+}
+
+//#endregion
+//#region lib/package-manager.ts
+async function findPackageManagerFromLockFile(rootDir) {
+	for (const packageManager of packageManagers) {
+		const lockFilePath = path.join(rootDir, lockfileNames[packageManager]);
+		if (await fs.pathExists(lockFilePath)) return packageManager;
+	}
+}
+function findPackageManagerFromUserAgent() {
+	return packageManagers.find((packageManager) => process.env.npm_config_user_agent?.startsWith(packageManager));
+}
+async function askForPackageManagerChoice() {
+	const hasYarn = shell.exec("yarn --version", { silent: true }).code === 0;
+	const hasPnpm = shell.exec("pnpm --version", { silent: true }).code === 0;
+	const hasBun = shell.exec("bun --version", { silent: true }).code === 0;
+	if (!hasYarn && !hasPnpm && !hasBun) return "npm";
+	return await prompts({
+		type: "select",
+		name: "packageManager",
+		message: "Select a package manager...",
+		choices: [
+			"npm",
+			hasYarn && "yarn",
+			hasPnpm && "pnpm",
+			hasBun && "bun"
+		].filter((p) => p !== false).map((p) => ({
+			title: p,
+			value: p
+		}))
+	}, { onCancel() {
+		logger.info`Falling back to name=${defaultPackageManager}`;
+	} }).then((result) => result.packageManager) ?? defaultPackageManager;
+}
+async function getPackageManager(dest, { packageManager, skipInstall }) {
+	if (packageManager && !packageManagers.includes(packageManager)) throw new Error(`Invalid package manager choice ${packageManager}. Must be one of ${packageManagers.join(", ")}`);
+	const fromLockfile = await findPackageManagerFromLockFile(dest);
+	if (fromLockfile) return fromLockfile;
+	if (packageManager) return packageManager;
+	const fromLockfileInCwd = await findPackageManagerFromLockFile(".");
+	if (fromLockfileInCwd) return fromLockfileInCwd;
+	const fromUserAgent = findPackageManagerFromUserAgent();
+	if (fromUserAgent) return fromUserAgent;
+	if (skipInstall) return defaultPackageManager;
+	return askForPackageManagerChoice();
+}
+function getInstallCommand(pkgManager) {
+	if (pkgManager === "yarn") return "yarn";
+	if (pkgManager === "bun") return "bun install";
+	return `${pkgManager} install --color always`;
+}
+
+//#endregion
+//#region lib/runtime.ts
+async function getRuntime() {
+	const hasBun = shell.exec("bun --version", { silent: true }).code === 0;
+	const hasDeno = shell.exec("deno --version", { silent: true }).code === 0;
+	if (!hasDeno && !hasBun) return "node";
+	return await prompts({
+		type: "select",
+		name: "runtime",
+		message: "Select a runtime...",
+		choices: [
+			"node",
+			hasBun && "bun",
+			hasDeno && "deno"
+		].filter((p) => p !== false).map((p) => ({
+			title: p,
+			value: p
+		}))
+	}, { onCancel() {
+		logger.info`Falling back to name=${defaultJavaScriptRuntime}`;
+	} }).then((result) => result.runtime) ?? defaultJavaScriptRuntime;
+}
+
+//#endregion
+//#region meta/apollo/package.json
+var package_default$1 = {
+	name: "@baeta/template-apollo",
+	version: "0.0.0",
+	"private": true,
+	type: "module",
+	scripts: {
+		"build": "baeta generate",
+		"start": "baeta generate --watch --run='node --watch --enable-source-maps --inspect src/app.ts'"
+	},
+	dependencies: {
+		"@apollo/server": "^5.2.0",
+		"@baeta/core": "workspace:^",
+		"@baeta/errors": "workspace:^",
+		"@baeta/extension-complexity": "workspace:^",
+		"graphql": "^16.12.0"
+	},
+	devDependencies: {
+		"@baeta/cli": "workspace:^",
+		"@types/bun": "^1.3.3",
+		"@types/deno": "^2.5.0",
+		"@types/node": "^22.19.1",
+		"typescript": "^5.9.3"
+	}
+};
+
+//#endregion
+//#region ../../tools/tsconfig/tsconfig.json
+var compilerOptions = {
+	"target": "es2024",
+	"lib": ["es2024"],
+	"noEmit": true,
+	"types": [],
+	"module": "esnext",
+	"moduleResolution": "bundler",
+	"strict": true,
+	"noImplicitAny": true,
+	"erasableSyntaxOnly": true,
+	"isolatedModules": true,
+	"esModuleInterop": true,
+	"verbatimModuleSyntax": true,
+	"allowImportingTsExtensions": true,
+	"allowSyntheticDefaultImports": true,
+	"skipLibCheck": true,
+	"forceConsistentCasingInFileNames": true
+};
+var tsconfig_default = {
+	$schema: "https://json.schemastore.org/tsconfig",
+	compilerOptions
+};
+
+//#endregion
+//#region versions.json
+var versions_default = {
+	"@baeta/cli": "2.0.0-next.8",
+	"@baeta/core": "2.0.0-next.8",
+	"create-baeta": "2.0.0-next.8",
+	"@baeta/directives": "2.0.0-next.8",
+	"@baeta/env": "2.0.0-next.8",
+	"@baeta/errors": "2.0.0-next.8",
+	"@baeta/extension-auth": "2.0.0-next.8",
+	"@baeta/extension-cache": "2.0.0-next.8",
+	"@baeta/extension-cache-cloudflare": "2.0.0-next.8",
+	"@baeta/extension-cache-keyv": "2.0.0-next.8",
+	"@baeta/extension-cache-redis": "2.0.0-next.8",
+	"@baeta/extension-cache-upstash": "2.0.0-next.8",
+	"@baeta/extension-complexity": "2.0.0-next.8",
+	"@baeta/generator": "2.0.0-next.3",
+	"@baeta/generator-sdk": "2.0.0-next.3",
+	"@baeta/plugin": "2.0.0-next.2",
+	"@baeta/plugin-cloudflare": "2.0.0-next.8",
+	"@baeta/plugin-directives": "2.0.0-next.8",
+	"@baeta/plugin-exec": "2.0.0-next.8",
+	"@baeta/plugin-gitignore": "2.0.0-next.8",
+	"@baeta/plugin-graphql": "2.0.0-next.8",
+	"@baeta/plugin-pagination": "2.0.0-next.8",
+	"@baeta/plugin-prisma": "2.0.0-next.8",
+	"@baeta/subscriptions-cloudflare": "0.2.0-next.2",
+	"@baeta/subscriptions-pubsub": "2.0.0-next.8",
+	"@baeta/util-encoding": "2.0.0-next.2",
+	"@baeta/util-env": "2.0.0-next.2",
+	"@baeta/util-log": "2.0.0-next.2",
+	"@baeta/util-path": "2.0.0-next.2"
+};
+
+//#endregion
+//#region templates/shared.ts
+function makeSharedTemplate(appName, runtime, packageJson) {
+	return [
+		makePackageJson(appName, runtime, packageJson),
+		{
+			relativePath: "./tsconfig.json",
+			content: JSON.stringify({
+				...tsconfig_default,
+				compilerOptions: {
+					...compilerOptions,
+					rootDir: "src",
+					outDir: "dist",
+					noEmit: true,
+					emitDeclarationOnly: false
+				},
+				exclude: ["baeta.ts"]
+			}, null, 2)
+		},
+		{
+			relativePath: "./src/modules/extensions.ts",
+			content: `import { createExtensions } from '@baeta/core';
+import { complexityExtension } from '@baeta/extension-complexity';
+import type { Context } from '../types/context.ts';
+
+const complexity = complexityExtension<Context>({
+	defaultComplexity: 1,
+	defaultListMultiplier: 10,
+	async limit(ctx) {
+		return {
+			depth: 10,
+			breadth: 50,
+			complexity: 1000,
+		};
+	},
+});
+
+export default createExtensions({
+	complexityExtension: complexity
+});
+`
+		},
+		{
+			relativePath: "./src/modules/user/user.gql",
+			content: `type User {
+	id: ID!
+	email: String!
+	lastName: String!
+	profile: String
+	givenName: String
+}
+
+input UserWhereUniqueInput {
+	id: ID!
+}
+
+type Query {
+	user(where: UserWhereUniqueInput!): User
+	users: [User!]
+}
+`
+		},
+		{
+			relativePath: "./src/modules/user/index.ts",
+			content: `import { UserModule } from './typedef.ts';
+
+const { Query, User } = UserModule;
+
+const userQuery = Query.user
+	.$use(async (next, { args }) => {
+		const result = await next();
+		console.log('Got user:', result, 'for args:', args);
+		return result;
+	})
+	.resolve(({ args }) => {
+		return {
+			id: args.where.id,
+			email: 'jon.doe@baeta.io',
+			lastName: 'Doe',
+			givenName: null,
+			profile: null,
+		};
+	});
+
+const usersQuery = Query.users.resolve(() => {
+	const users = Array.from({ length: 10 }).map((_, i) => ({
+		id: i.toString(),
+		email: \`jon.doe\${i}@baeta.io\`,
+		lastName: \`Doe \${i}\`,
+		givenName: null,
+		profile: null,
+	}));
+	return users;
+});
+
+export default UserModule.$schema({
+	User: User.$fields({
+		id: User.id.key('id'),
+		email: User.email.key('email'),
+		lastName: User.lastName.key('lastName'),
+		givenName: User.givenName.key('givenName').undefinedAsNull(),
+		profile: User.profile.key('profile').undefinedAsNull(),
+	}),
+	Query: Query.$fields({
+		user: userQuery,
+		users: usersQuery,
+	}),
+});
+`
+		},
+		{
+			relativePath: "./src/modules/user-photos/user-photos.gql",
+			content: `type UserPhoto {
+	id: ID!
+	userId: ID!
+	url: String!
+}
+
+extend type User {
+	photos: [UserPhoto!]
+}
+`
+		},
+		{
+			relativePath: "./src/modules/user-photos/index.ts",
+			content: `import { UserPhotosModule } from './typedef.ts';
+
+const { User, UserPhoto } = UserPhotosModule;
+
+export default UserPhotosModule.$schema({
+	User: User.$fields({
+		photos: User.photos.resolve(({ source }) => {
+			return Array.from({ length: 10 }).map((_, i) => ({
+				id: \`u\${source.id}_p\${i}\`,
+				userId: source.id,
+				url: \`https://baeta.io/user/\${source.id}/photo/\${i}.png\`,
+			}));
+		}),
+	}),
+	UserPhoto: UserPhoto.$fields({
+		id: UserPhoto.id.key('id'),
+		url: UserPhoto.url.key('url'),
+		userId: UserPhoto.userId.key('userId'),
+	}),
+});
+`
+		},
+		{
+			relativePath: "./src/modules/types.ts",
+			content: `import type { GraphQLResolveInfo } from 'graphql';
+import type { BaseObjectTypes, BaseScalars } from '../__generated__/utility.ts';
+import type { Context } from '../types/context.ts';
+
+export interface Scalars extends BaseScalars {}
+
+export interface ObjectTypes extends BaseObjectTypes {
+	User: {
+		id: string;
+		email: string;
+		lastName: string;
+		givenName?: string | null;
+		profile?: string | null;
+	};
+}
+
+export type Ctx = Context;
+
+export type Info = GraphQLResolveInfo;
+`
+		},
+		{
+			relativePath: "./baeta.ts",
+			content: `import { defineConfig } from '@baeta/cli';
+
+export default defineConfig({
+	graphql: {
+		schemas: ['src/**/*.gql'],
+	},
+});
+`
+		},
+		{
+			relativePath: "./.gitignore",
+			content: `# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+lerna-debug.log*
+.pnpm-debug.log*
+
+# Diagnostic reports (https://nodejs.org/api/report.html)
+report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json
+
+# Runtime data
+pids
+*.pid
+*.seed
+*.pid.lock
+
+# Directory for instrumented libs generated by jscoverage/JSCover
+lib-cov
+
+# Coverage directory used by tools like istanbul
+coverage
+*.lcov
+
+# nyc test coverage
+.nyc_output
+
+# Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files)
+.grunt
+
+# Bower dependency directory (https://bower.io/)
+bower_components
+
+# node-waf configuration
+.lock-wscript
+
+# Compiled binary addons (https://nodejs.org/api/addons.html)
+build/Release
+
+# Dependency directories
+node_modules/
+jspm_packages/
+
+# Snowpack dependency directory (https://snowpack.dev/)
+web_modules/
+
+# TypeScript cache
+*.tsbuildinfo
+
+# Optional npm cache directory
+.npm
+
+# Optional eslint cache
+.eslintcache
+
+# Optional stylelint cache
+.stylelintcache
+
+# Microbundle cache
+.rpt2_cache/
+.rts2_cache_cjs/
+.rts2_cache_es/
+.rts2_cache_umd/
+
+# Optional REPL history
+.node_repl_history
+
+# Output of 'npm pack'
+*.tgz
+
+# Yarn Integrity file
+.yarn-integrity
+
+# dotenv environment variable files
+.env
+.env.development.local
+.env.test.local
+.env.production.local
+.env.local
+
+# parcel-bundler cache (https://parceljs.org/)
+.cache
+.parcel-cache
+
+# Next.js build output
+.next
+out
+
+# Nuxt.js build / generate output
+.nuxt
+dist
+
+# Gatsby files
+.cache/
+# Comment in the public line in if your project uses Gatsby and not Next.js
+# https://nextjs.org/blog/next-9-1#public-directory-support
+# public
+
+# vuepress build output
+.vuepress/dist
+
+# vuepress v2.x temp and cache directory
+.temp
+.cache
+
+# vitepress build output
+**/.vitepress/dist
+
+# vitepress cache directory
+**/.vitepress/cache
+
+# Docusaurus cache and generated files
+.docusaurus
+
+# Serverless directories
+.serverless/
+
+# FuseBox cache
+.fusebox/
+
+# DynamoDB Local files
+.dynamodb/
+
+# TernJS port file
+.tern-port
+
+# Stores VSCode versions used for testing VSCode extensions
+.vscode-test
+
+# yarn v2
+.yarn/cache
+.yarn/unplugged
+.yarn/build-state.yml
+.yarn/install-state.gz
+.pnp.*
+`
+		}
+	];
+}
+function makePackageJson(appName, runtime, packageJson) {
+	const meta = structuredClone(packageJson);
+	for (const [dep, version$2] of Object.entries(versions_default)) if (dep in meta.dependencies) meta.dependencies[dep] = version$2;
+	else if (dep in packageJson.devDependencies) meta.devDependencies[dep] = version$2;
+	if (runtime === "node") {
+		meta.devDependencies["@types/bun"] = void 0;
+		meta.devDependencies["@types/deno"] = void 0;
+	}
+	if (runtime === "bun") {
+		meta.scripts.start = `baeta generate --watch --run='bun --watch --inspect src/app.ts'`;
+		meta.devDependencies["@types/node"] = void 0;
+		meta.devDependencies["@types/deno"] = void 0;
+	}
+	if (runtime === "deno") {
+		meta.scripts.start = `baeta generate --watch --run='deno --watch --allow-env --allow-read --allow-net src/app.ts'`;
+		meta.devDependencies["@types/node"] = void 0;
+		meta.devDependencies["@types/bun"] = void 0;
+	}
+	meta.name = appName;
+	return {
+		relativePath: "./package.json",
+		content: JSON.stringify(meta, null, 2)
+	};
+}
+
+//#endregion
+//#region templates/apollo.ts
+async function makeApolloTemplate(appName, runtime) {
+	return [
+		...makeSharedTemplate(appName, runtime, package_default$1),
+		{
+			relativePath: "./src/types/context.ts",
+			content: `export type Context = {
+	userId?: string;
+};
+`
+		},
+		{
+			relativePath: "./src/app.ts",
+			content: `import { ApolloServer } from '@apollo/server';
+import { startStandaloneServer } from '@apollo/server/standalone';
+import { createApplication } from '@baeta/core';
+import modules from './modules/index.ts';
+import type { Context } from './types/context.ts';
+
+const baeta = createApplication({
+	modules,
+});
+
+const server = new ApolloServer<Context>({
+	schema: baeta.schema,
+});
+
+const { url } = await startStandaloneServer(server, {
+	listen: { port: 4000 },
+});
+
+console.log(\`🚀  Server ready at: \${url}\`);
+`
+		}
+	];
+}
+
+//#endregion
+//#region meta/yoga/package.json
+var package_default = {
+	name: "@baeta/template-yoga",
+	version: "0.0.0",
+	"private": true,
+	type: "module",
+	scripts: {
+		"build": "baeta generate",
+		"start": "baeta generate --watch --run='node --watch --enable-source-maps --inspect src/app.ts'"
+	},
+	dependencies: {
+		"@baeta/core": "workspace:^",
+		"@baeta/errors": "workspace:^",
+		"@baeta/extension-complexity": "workspace:^",
+		"graphql": "^16.12.0",
+		"graphql-yoga": "^5.17.0"
+	},
+	devDependencies: {
+		"@baeta/cli": "workspace:^",
+		"@types/bun": "^1.3.3",
+		"@types/deno": "^2.5.0",
+		"@types/node": "^22.19.1",
+		"typescript": "^5.9.3"
+	}
+};
+
+//#endregion
+//#region templates/yoga.ts
+async function makeYogaTemplate(appName, runtime) {
+	return [
+		...makeSharedTemplate(appName, runtime, package_default),
+		...makeRuntimeFiles(runtime),
+		{
+			relativePath: "./src/types/context.ts",
+			content: `export type Context = {
+	appVersion: string;
+};
+
+export type ServerContext = {};
+`
+		}
+	];
+}
+function makeRuntimeFiles(runtime) {
+	switch (runtime) {
+		case "bun": return makeBunFiles();
+		case "deno": return makeDenoFiles();
+		case "node": return makeNodeFiles();
+		default: return [];
+	}
+}
+function makeBunFiles() {
+	return [{
+		relativePath: "./src/app.ts",
+		content: `import { createApplication } from '@baeta/core';
+import { createYoga } from 'graphql-yoga';
+import modules from './modules/index.ts';
+import type { Context, ServerContext } from './types/context.ts';
+
+const baeta = createApplication({
+	modules,
+});
+
+export const yoga = createYoga<ServerContext, Context>({
+	schema: baeta.schema,
+	context: {
+		appVersion: '1.0.0',
+	},
+});
+
+Bun.serve({
+	fetch: yoga.fetch,
+	port: 4000,
+});
+
+console.log(\`🚀 Server ready at http://localhost:4000\${yoga.graphqlEndpoint}\`);
+`
+	}];
+}
+function makeDenoFiles() {
+	return [{
+		relativePath: "./src/app.ts",
+		content: `import { createApplication } from '@baeta/core';
+import { createYoga } from 'graphql-yoga';
+import modules from './modules/index.ts';
+import type { Context, ServerContext } from './types/context.ts';
+
+const baeta = createApplication({
+	modules,
+});
+
+export const yoga = createYoga<ServerContext, Context>({
+	schema: baeta.schema,
+	context: {
+		appVersion: '1.0.0',
+	},
+});
+
+Deno.serve(
+	{
+		port: 4000,
+		onListen() {
+			console.log(\`🚀 Server ready at http://localhost:4000\${yoga.graphqlEndpoint}\`);
+		},
+	},
+	yoga.fetch,
+);
+`
+	}];
+}
+function makeNodeFiles() {
+	return [{
+		relativePath: "./src/app.ts",
+		content: `import { createServer } from 'node:http';
+import { createApplication } from '@baeta/core';
+import { createYoga } from 'graphql-yoga';
+import modules from './modules/index.ts';
+import type { Context, ServerContext } from './types/context.ts';
+
+const baeta = createApplication({
+	modules,
+});
+
+export const yoga = createYoga<ServerContext, Context>({
+	schema: baeta.schema,
+	context: {
+		appVersion: '1.0.0',
+	},
+});
+
+const server = createServer(yoga);
+
+server.listen(4000, () => {
+	console.log(\`🚀 Server ready at http://localhost:4000\${yoga.graphqlEndpoint}\`);
+});
+`
+	}];
+}
+
+//#endregion
+//#region lib/templates.ts
+function createTemplateChoices() {
+	return templates.map((template) => ({
+		title: template,
+		value: template
+	}));
+}
+async function askTemplateChoice() {
+	return prompts({
+		type: "select",
+		name: "template",
+		message: "Select a template below...",
+		choices: createTemplateChoices()
+	}, { onCancel() {
+		logger.error("A choice is required.");
+		process.exit(1);
+	} }).then((result) => {
+		return result.template;
+	});
+}
+async function getTemplate(reqTemplate) {
+	const template = (reqTemplate ? templates.find((t) => t === reqTemplate) : null) ?? await askTemplateChoice();
+	if (!template) throw new Error("Template not found");
+	return template;
+}
+function getTemplateFiles(template, appName, runtime) {
+	switch (template) {
+		case "yoga": return makeYogaTemplate(appName, runtime);
+		case "apollo": return makeApolloTemplate(appName, runtime);
+		default: return [];
+	}
+}
+async function copyTemplate(appName, runtime, template, dest) {
+	const promises = (await getTemplateFiles(template, appName, runtime)).map((file) => {
+		const filePath = path.join(dest, file.relativePath);
+		return fs.ensureDir(path.dirname(filePath)).then(() => fs.writeFile(filePath, file.content));
+	});
+	await Promise.all(promises);
+}
+
+//#endregion
+//#region lib/handler.ts
+async function handler(args) {
+	const appName = await getAppName(args.appName, args.rootDir);
+	const dest = path.resolve(args.rootDir, appName);
+	const template = await getTemplate(args.template);
+	const runtime = await getRuntime();
+	logger.info("Creating new Baeta project...");
+	try {
+		await copyTemplate(appName, runtime, template, dest);
+	} catch (err) {
+		logger.error`Copying Baeta template name=${template} failed!`;
+		throw err;
+	}
+	const pkgManager = await getPackageManager(dest, args);
+	const runCommand = pkgManager === "npm" || pkgManager === "bun" ? "run " : "";
+	const start = `${pkgManager} start`;
+	const build = `${pkgManager} ${runCommand}build`;
+	const cd = `cd ${dest}`;
+	const install = `${pkgManager} install`;
+	if (!args.skipInstall) {
+		shell.cd(dest);
+		logger.info`Installing dependencies with name=${pkgManager}...`;
+		if (shell.exec(getInstallCommand(pkgManager), { env: {
+			...process.env,
+			...supportsColor.stdout ? { FORCE_COLOR: "1" } : {}
+		} }).code !== 0) {
+			console.error("Dependency installation failed.");
+			logger.error("Dependency installation failed.");
+			logger.info`The app directory has already been created, and you can retry by typing:
+
+code=${cd}
+code=${install}`;
+			process.exit(0);
+		}
+	}
+	logger.success`Created name=${dest}.`;
+	logger.info`Inside that directory, you can run several commands:
+
+  code=${start}
+    Starts the development server.
+
+  code=${build}
+    Generates the Baeta application.
+
+We recommend that you begin by typing:
+
+  code=${cd}
+  code=${start}
+`;
+}
+
+//#endregion
+export { getInstallCommand as a, defaultJavaScriptRuntime as c, packageManagers as d, runtimes as f, getRuntime as i, defaultPackageManager as l, copyTemplate as n, getPackageManager as o, templates as p, getTemplate as r, getAppName as s, handler as t, lockfileNames as u };
+//# sourceMappingURL=handler-DJjeIx4h.js.map