convex
Version:
Client for the Convex Cloud
192 lines (191 loc) • 7.03 kB
JavaScript
;
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var init_exports = {};
__export(init_exports, {
init: () => init,
optins: () => optins
});
module.exports = __toCommonJS(init_exports);
var import_chalk = __toESM(require("chalk"));
var import_boxen = __toESM(require("boxen"));
var import_config = require("./config.js");
var import_utils = require("./utils.js");
var import_inquirer = __toESM(require("inquirer"));
var import_ora = __toESM(require("ora"));
var import_path = __toESM(require("path"));
var import_codegen = require("./codegen");
const cwd = import_path.default.basename(process.cwd());
async function init(ctx, project, team) {
{
const configPath = await (0, import_config.configFilepath)(ctx);
if (ctx.fs.exists(configPath)) {
console.error(
import_chalk.default.green(`Found existing project config "${configPath}"`)
);
return;
}
const shouldContinue = await optins(ctx);
if (!shouldContinue) {
return await ctx.fatalError(1, void 0);
}
const selectedTeam = await (0, import_utils.validateOrSelectTeam)(
ctx,
team,
"Choose which team to create this project in:"
);
let projectName = project || cwd;
if (process.stdin.isTTY && !project) {
projectName = (await import_inquirer.default.prompt([
{
type: "input",
name: "project",
message: "Enter a name for your project:",
default: cwd
}
])).project;
}
const spinner = ctx.spinner = (0, import_ora.default)({
text: "Creating new Convex project...\n",
stream: process.stdout
}).start();
let projectSlug, teamSlug, prodUrl, adminKey, projectsRemaining, projectConfig, modules;
try {
({ projectSlug, teamSlug, prodUrl, adminKey, projectsRemaining } = await create_project(ctx, selectedTeam, projectName));
({ projectConfig, modules } = await (0, import_config.pullConfig)(
ctx,
projectSlug,
teamSlug,
prodUrl,
adminKey
));
} catch (err) {
spinner.fail("Unable to create project.");
return await (0, import_utils.fatalServerErr)(ctx, err);
}
spinner.succeed(`Successfully created project!`);
console.log(
import_chalk.default.green(
`Your account now has ${projectsRemaining} projects remaining.`
)
);
if (modules.length > 0) {
console.error(import_chalk.default.red("Error: Unexpected modules in new project"));
return await ctx.fatalError(1, void 0);
}
const packages = await (0, import_utils.loadPackageJson)(ctx);
const isCreateReactApp = !!packages.filter(
({ name }) => name === "react-scripts"
).length;
if (isCreateReactApp) {
projectConfig.functions = `src/${projectConfig.functions}`;
}
await (0, import_config.writeProjectConfig)(ctx, projectConfig);
await (0, import_codegen.doInitCodegen)(
ctx,
(0, import_utils.functionsDir)(configPath, projectConfig),
true
);
{
const { projectConfig: projectConfig2, configPath: configPath2 } = await (0, import_config.readProjectConfig)(ctx);
await (0, import_codegen.doCodegen)({
ctx,
projectConfig: projectConfig2,
configPath: configPath2,
deploymentType: "dev",
typeCheckMode: "disable",
quiet: true
});
}
const boxedText = import_chalk.default.white("Project ready:\n") + import_chalk.default.whiteBright.bold(projectName) + "\n" + import_chalk.default.whiteBright(projectConfig.project);
const boxenOptions = {
padding: 1,
margin: 1,
borderColor: "green",
backgroundColor: "#555555"
};
console.log((0, import_boxen.default)(boxedText, boxenOptions));
console.log(
import_chalk.default.green("Write your Convex functions in"),
import_chalk.default.green.bold((0, import_utils.functionsDir)(configPath, projectConfig))
);
console.log("Configuration settings written to", import_chalk.default.bold(configPath));
console.log(import_chalk.default.bold("\nWe would love feedback at either:"));
console.log("- https://convex.dev/community");
console.log("- support@convex.dev");
console.log(
"\nSee documentation at",
import_chalk.default.bold("https://docs.convex.dev"),
"for next steps."
);
}
}
async function create_project(ctx, team, projectName) {
const provisioningArgs = {
team,
backendVersionOverride: process.env.CONVEX_BACKEND_VERSION_OVERRIDE,
projectName
};
const data = await (0, import_utils.bigBrainAPI)(
ctx,
"POST",
"create_project",
provisioningArgs
);
const projectSlug = data.projectSlug;
const teamSlug = data.teamSlug;
const prodUrl = data.prodUrl;
const adminKey = data.adminKey;
const projectsRemaining = data.projectsRemaining;
if (projectSlug === void 0 || teamSlug == void 0 || prodUrl === void 0 || adminKey === void 0 || projectsRemaining === void 0) {
throw new Error(
"Unknown error during provisioning: " + JSON.stringify(data)
);
}
return { projectSlug, teamSlug, prodUrl, adminKey, projectsRemaining };
}
async function optins(ctx) {
const data = await (0, import_utils.bigBrainAPI)(ctx, "POST", "check_opt_ins", {});
if (data.optInsToAccept.length == 0) {
return true;
}
for (const optInToAccept of data.optInsToAccept) {
const confirmed = (await import_inquirer.default.prompt([
{
type: "confirm",
name: "confirmed",
message: optInToAccept.message
}
])).confirmed;
if (!confirmed) {
console.log("Please accept the Terms of Service to use Convex.");
return Promise.resolve(false);
}
}
const optInsAccepted = data.optInsToAccept.map((o) => o.optIn);
const args = { optInsAccepted };
await (0, import_utils.bigBrainAPI)(ctx, "POST", "accept_opt_ins", args);
return true;
}
//# sourceMappingURL=init.js.map