void 0.1.6 → 0.7.0

package/dist/domain-BGofcQ6I.mjs

@@ -0,0 +1,79 @@
+import { s as import_picocolors } from "./output-BwlcIYSR.mjs";
+import { c as R, u as Se } from "./dist-Dayj3gCK.mjs";
+import { r as readProjectConfig } from "./project-TqORyHn8.mjs";
+import { n as PlatformClient, s as getToken } from "./client-snXOjrp1.mjs";
+//#region src/cli/domain.ts
+async function runDomainCommand(root, args) {
+	const token = getToken(root);
+	if (!token) {
+		R.error("Not logged in. Run `void auth login` first.");
+		process.exit(1);
+	}
+	const client = new PlatformClient(token, { root });
+	const requestedSlug = args.projectSlug ?? process.env.VOID_PROJECT?.trim();
+	let projectId;
+	if (requestedSlug) {
+		const project = (await client.listProjects()).find((p) => p.slug === requestedSlug);
+		if (!project) {
+			R.error(`project: No project found with slug '${requestedSlug}'.`);
+			process.exit(1);
+		}
+		projectId = project.id;
+	} else {
+		const config = readProjectConfig(root);
+		if (!config) {
+			R.error("No linked project. Run `void project link` or pass --project <name>.");
+			process.exit(1);
+		}
+		projectId = config.projectId;
+	}
+	switch (args.subcommand) {
+		case "add": return domainAdd(client, projectId, args.hostname);
+		case "delete": return domainRemove(client, projectId, args.hostname);
+		case "list": return domainList(client, projectId);
+		case "status": return domainStatus(client, projectId, args.hostname);
+	}
+}
+async function domainAdd(client, projectId, hostname) {
+	const domain = await client.addDomain(projectId, hostname);
+	R.success(`Domain ${hostname} added (status: ${domain.status})`);
+	Se(`Add a CNAME record:\n  ${hostname} → ${domain.cname_target}`, "DNS Setup");
+	R.info("Run `void domain status " + hostname + "` to check verification progress.");
+}
+async function domainRemove(client, projectId, hostname) {
+	const domain = (await client.listDomains(projectId)).find((d) => d.hostname === hostname);
+	if (!domain) {
+		R.error(`domain: Domain '${hostname}' not found on this project.`);
+		process.exit(1);
+	}
+	await client.removeDomain(projectId, domain.id);
+	R.success(`Domain ${hostname} removed.`);
+}
+async function domainList(client, projectId) {
+	const domains = await client.listDomains(projectId);
+	if (domains.length === 0) {
+		R.info("No custom domains configured.");
+		return;
+	}
+	Se(domains.map((d) => {
+		const status = d.status === "active" ? import_picocolors.default.green("active") : import_picocolors.default.yellow(d.status);
+		return `  ${d.hostname}  ${status}`;
+	}).join("\n"), "Custom Domains");
+}
+async function domainStatus(client, projectId, hostname) {
+	const domain = (await client.listDomains(projectId)).find((d) => d.hostname === hostname);
+	if (!domain) {
+		R.error(`domain: Domain '${hostname}' not found on this project.`);
+		process.exit(1);
+	}
+	const status = await client.getDomainStatus(projectId, domain.id);
+	const lines = [
+		`Hostname:    ${status.hostname}`,
+		`Status:      ${status.status}`,
+		`SSL Status:  ${status.ssl_status}`
+	];
+	if (status.verification_errors && status.verification_errors.length > 0) lines.push(`Errors:      ${status.verification_errors.join(", ")}`);
+	Se(lines.join("\n"), "Domain Status");
+}
+//#endregion
+export { runDomainCommand };

package/dist/dotenv-DwO4ti0Z.mjs

@@ -0,0 +1,173 @@
+import { existsSync, readFileSync } from "node:fs";
+//#region src/shared/dotenv.ts
+/**
+* Shared dotenv parser + variable expander used by every CLI path that reads
+* `.env*` files (`void env check`, `void deploy`, `void init` scaffold
+* inference). A single source of truth avoids the drift we hit when two
+* hand-rolled parsers diverged on quoting / expansion semantics.
+*
+* Expansion supports `${VAR}` and `$VAR`, a `\$VAR` literal-escape, and
+* transitive references across earlier entries in the same record. Cycles
+* are detected and fall through to the raw literal rather than looping.
+*
+* Security note: expansion is deliberately scoped to the in-file record.
+* We do NOT consult `process.env` the way `dotenv-expand` does — a shell
+* env leaking into an `.env.example` via expansion would silently reveal
+* developer machine state in committed output, and `void env check` /
+* `void deploy` would then pass with values that aren't present in CI.
+*
+* The runtime path (Vite's own `loadEnv`) DOES consult `process.env` for
+* expansion. That's a deliberate Vite choice; `filterLoadedEnv` strips
+* shell pollution from the final worker vars so the two sides agree on
+* the observable surface even when expansion sources differ.
+*
+* This module is a leaf — it must not import from `../log` or any non-leaf
+* module so that the prerender subprocess's worker bundle doesn't pick up
+* unwanted transitive dependencies. Warnings are surfaced through the
+* `onWarn` callback and left for the caller to route.
+*/
+/** Valid dotenv key — ASCII letter/underscore followed by letters/digits/underscore. */
+const VALID_KEY = /^[A-Za-z_][A-Za-z0-9_]*$/;
+/**
+* Parse a single `KEY=VALUE` line into `{ key, value }`, stripping matching
+* single/double quotes around the value. Returns `null` for blanks, comments,
+* and non-assignment lines.
+*/
+function parseDotenvLine(line) {
+	const trimmed = line.trim();
+	if (!trimmed || trimmed.startsWith("#")) return null;
+	const eq = trimmed.indexOf("=");
+	if (eq === -1) return null;
+	const key = trimmed.slice(0, eq).trim();
+	let value = trimmed.slice(eq + 1).trim();
+	if (value.startsWith("\"") && value.endsWith("\"") || value.startsWith("'") && value.endsWith("'")) value = value.slice(1, -1);
+	return {
+		key,
+		value
+	};
+}
+/**
+* Parse the raw contents of a dotenv file into a record, optionally
+* expanding `${VAR}` / `$VAR` references against earlier entries.
+*/
+function parseDotenv(content, options = {}) {
+	const { expand: shouldExpand = true, skipInvalidKeys = true, onWarn } = options;
+	const env = {};
+	for (const line of content.split("\n")) {
+		const parsed = parseDotenvLine(line);
+		if (!parsed) continue;
+		if (!VALID_KEY.test(parsed.key)) {
+			if (skipInvalidKeys) continue;
+			throw new Error(`dotenv: Invalid key '${parsed.key}'.`);
+		}
+		env[parsed.key] = parsed.value;
+	}
+	return shouldExpand ? expandDotenv(env, { onWarn }) : env;
+}
+/**
+* Read and parse a dotenv file. Returns `{}` when the file is missing so
+* callers can treat "no file" and "empty file" identically.
+*/
+function parseDotenvFile(filePath, options = {}) {
+	if (!existsSync(filePath)) return {};
+	return parseDotenv(readFileSync(filePath, "utf-8"), options);
+}
+/**
+* Expand `${VAR}` / `$VAR` references in every value of a record against
+* the other entries in that same record. Matches the surface of
+* `dotenv-expand` minus the `process.env` fallback.
+*
+* Semantics:
+*   - `${VAR}` and `$VAR` both resolve (bare form stops at the first
+*     non-identifier character).
+*   - `\$VAR` stays literal; the backslash is consumed.
+*   - Nested refs resolve transitively — `A=${B}`, `B=${C}`, `C=v` → `A=v`.
+*   - Cycles are detected; the offending value keeps its raw literal and
+*     `onWarn` fires once per cycle seen.
+*   - Missing refs expand to the empty string, matching dotenv-expand.
+*
+* The input record is not mutated; a fresh object is returned.
+*/
+function expandDotenv(input, options = {}) {
+	const out = {};
+	const resolving = /* @__PURE__ */ new Set();
+	const warned = /* @__PURE__ */ new Set();
+	function resolveKey(key) {
+		if (!(key in input)) return "";
+		if (key in out) return out[key];
+		if (resolving.has(key)) {
+			if (!warned.has(key) && options.onWarn) {
+				warned.add(key);
+				options.onWarn(`dotenv expansion cycle detected at "${key}" — leaving raw value in place`);
+			}
+			return input[key];
+		}
+		resolving.add(key);
+		const expanded = expandValue(input[key], resolveKey);
+		resolving.delete(key);
+		out[key] = expanded;
+		return expanded;
+	}
+	for (const key of Object.keys(input)) resolveKey(key);
+	return out;
+}
+/**
+* Expand a single value string. `resolve` returns the fully-expanded value
+* for a referenced key (or `''` when missing). Backslash-escapes (`\$VAR`,
+* `\${VAR}`) keep the `$...` literal and consume the backslash.
+*/
+function expandValue(value, resolve) {
+	let result = "";
+	let i = 0;
+	while (i < value.length) {
+		const ch = value[i];
+		if (ch === "\\" && i + 1 < value.length && value[i + 1] === "$") {
+			result += "$";
+			i += 2;
+			continue;
+		}
+		if (ch !== "$") {
+			result += ch;
+			i++;
+			continue;
+		}
+		const next = value[i + 1];
+		if (next === "{") {
+			const end = value.indexOf("}", i + 2);
+			if (end === -1) {
+				result += ch;
+				i++;
+				continue;
+			}
+			const key = value.slice(i + 2, end);
+			if (VALID_KEY.test(key)) result += resolve(key);
+			else result += value.slice(i, end + 1);
+			i = end + 1;
+			continue;
+		}
+		if (next && /[A-Za-z_]/.test(next)) {
+			let j = i + 1;
+			while (j < value.length && /[A-Za-z0-9_]/.test(value[j])) j++;
+			const key = value.slice(i + 1, j);
+			result += resolve(key);
+			i = j;
+			continue;
+		}
+		result += ch;
+		i++;
+	}
+	return result;
+}
+/**
+* Merge multiple parsed dotenv records with later-entries-win semantics,
+* then expand across the combined set. This is the recommended path for
+* callers reading multiple `.env*` files (Vite-style precedence), since
+* expansion sees every earlier file's keys at once.
+*/
+function mergeAndExpand(records, options = {}) {
+	const merged = {};
+	for (const record of records) Object.assign(merged, record);
+	return expandDotenv(merged, options);
+}
+//#endregion
+export { mergeAndExpand as n, parseDotenvFile as r, expandDotenv as t };

package/dist/drizzle-NnudE_UN.mjs

@@ -0,0 +1,232 @@
+import { a as isVoidSocialAuthProvider } from "./providers-B3aMxWzP.mjs";
+import { getAuthTables, getSchema } from "better-auth/db";
+//#region src/auth/drizzle.ts
+const DEFAULT_TABLE_ORDER = Number.MAX_SAFE_INTEGER;
+function resolveEmailAndPassword(configuredProviders) {
+	if (!configuredProviders || configuredProviders.includes("email")) return { enabled: true };
+}
+function resolvePlaceholderSocialProviders(configuredProviders) {
+	if (!configuredProviders) return;
+	const providers = {};
+	for (const provider of configuredProviders) {
+		if (!isVoidSocialAuthProvider(provider)) continue;
+		providers[provider] = {
+			clientId: `void-${provider}-client-id`,
+			clientSecret: `void-${provider}-client-secret`
+		};
+	}
+	return Object.keys(providers).length > 0 ? providers : void 0;
+}
+function resolveSchemaUserConfig(userConfig, defaults, dialect, env) {
+	if (!userConfig) return defaults;
+	if (typeof userConfig === "function") return userConfig({
+		defaults,
+		request: new Request("http://localhost/api/auth"),
+		env,
+		dialect
+	});
+	return {
+		...defaults,
+		...userConfig
+	};
+}
+function resolveSchemaOptions(runtime, env) {
+	const origin = "http://localhost";
+	const emailAndPassword = resolveEmailAndPassword(runtime.providers);
+	const socialProviders = resolvePlaceholderSocialProviders(runtime.providers);
+	const defaults = {
+		baseURL: origin,
+		basePath: "/api/auth",
+		secret: "void-build-better-auth-secret",
+		database: {},
+		trustedOrigins: [origin],
+		...emailAndPassword ? { emailAndPassword } : {},
+		...socialProviders ? { socialProviders } : {}
+	};
+	return resolveSchemaUserConfig(runtime.userConfig, defaults, runtime.dialect, env);
+}
+function resolveIdStrategy(options) {
+	const generateId = options.advanced?.database?.generateId;
+	if (generateId === "serial") return "serial";
+	if (generateId === "uuid") return "uuid";
+	return "text";
+}
+function sanitizeIdentifier(name) {
+	const value = name.replace(/[^A-Za-z0-9_$]/g, "_");
+	return /^[A-Za-z_$]/.test(value) ? value : `_${value}`;
+}
+function isJsonField(field) {
+	return field.type === "json" || field.type === "string[]" || field.type === "number[]";
+}
+function renderEnumValues(values) {
+	return `[${values.map((value) => JSON.stringify(value)).join(", ")}] as const`;
+}
+function resolveFieldName(defaultFieldName, field) {
+	return field.fieldName ?? defaultFieldName;
+}
+function resolveReferenceFieldName(schema, model, field) {
+	if (field === "id") return "id";
+	const referencedField = schema[model]?.fields[field];
+	return referencedField ? resolveFieldName(field, referencedField) : field;
+}
+function createColumnBuilder(dialect, idStrategy, fieldName, field) {
+	const useIdType = fieldName === "id" || field.references?.field === "id";
+	if (dialect === "postgresql") {
+		if (useIdType) {
+			if (idStrategy === "serial") return `integer(${JSON.stringify(fieldName)})`;
+			if (idStrategy === "uuid") return `uuid(${JSON.stringify(fieldName)})`;
+			return `text(${JSON.stringify(fieldName)})`;
+		}
+		if (Array.isArray(field.type)) return `text(${JSON.stringify(fieldName)}, { enum: ${renderEnumValues(field.type)} })`;
+		if (isJsonField(field)) return `jsonb(${JSON.stringify(fieldName)})`;
+		switch (field.type) {
+			case "boolean": return `boolean(${JSON.stringify(fieldName)})`;
+			case "date": return `timestamp(${JSON.stringify(fieldName)}, { mode: "date", withTimezone: true })`;
+			case "number": return field.bigint ? `bigint(${JSON.stringify(fieldName)}, { mode: "number" })` : `integer(${JSON.stringify(fieldName)})`;
+			case "string": return `text(${JSON.stringify(fieldName)})`;
+			default: return `text(${JSON.stringify(fieldName)})`;
+		}
+	}
+	if (useIdType) {
+		if (idStrategy === "serial") return `integer(${JSON.stringify(fieldName)})`;
+		return `text(${JSON.stringify(fieldName)})`;
+	}
+	if (Array.isArray(field.type)) return `text(${JSON.stringify(fieldName)}, { enum: ${renderEnumValues(field.type)} })`;
+	if (isJsonField(field)) return `text(${JSON.stringify(fieldName)}, { mode: "json" })`;
+	switch (field.type) {
+		case "boolean": return `integer(${JSON.stringify(fieldName)}, { mode: "boolean" })`;
+		case "date": return `integer(${JSON.stringify(fieldName)}, { mode: "timestamp_ms" })`;
+		case "number": return `integer(${JSON.stringify(fieldName)})`;
+		case "string": return `text(${JSON.stringify(fieldName)})`;
+		default: return `text(${JSON.stringify(fieldName)})`;
+	}
+}
+function createColumnDefinition(dialect, schema, idStrategy, defaultToVariable, defaultFieldName, field) {
+	const actualFieldName = resolveFieldName(defaultFieldName, field);
+	const parts = [createColumnBuilder(dialect, idStrategy, actualFieldName, field)];
+	if (actualFieldName === "id") parts.push(".primaryKey()");
+	if (field.required !== false || actualFieldName === "id") parts.push(".notNull()");
+	if (field.references) {
+		const referenceModel = Object.entries(schema).find(([_, value]) => value.modelName === field.references?.model)?.[0] ?? field.references.model;
+		const referenceVariable = defaultToVariable.get(referenceModel);
+		if (referenceVariable) {
+			const referenceFieldName = resolveReferenceFieldName(schema, referenceModel, field.references.field);
+			parts.push(`.references(() => ${referenceVariable}[${JSON.stringify(referenceFieldName)}], { onDelete: ${JSON.stringify(field.references.onDelete ?? "cascade")} })`);
+		}
+	}
+	if (field.unique && actualFieldName !== "id") parts.push(".unique()");
+	return parts.join("");
+}
+function collectCoreImports(dialect, schema, idStrategy) {
+	const imports = new Set([dialect === "postgresql" ? "pgTable" : "sqliteTable", "text"]);
+	if (idStrategy === "serial") imports.add("integer");
+	if (idStrategy === "uuid" && dialect === "postgresql") imports.add("uuid");
+	for (const [, table] of Object.entries(schema)) for (const [defaultFieldName, field] of Object.entries(table.fields)) {
+		if (resolveFieldName(defaultFieldName, field) === "id" || field.references?.field === "id") {
+			if (idStrategy === "serial") imports.add("integer");
+			if (idStrategy === "uuid" && dialect === "postgresql") imports.add("uuid");
+			continue;
+		}
+		if (field.index) imports.add("index");
+		if (Array.isArray(field.type) || field.type === "string") {
+			imports.add("text");
+			continue;
+		}
+		if (isJsonField(field)) {
+			imports.add(dialect === "postgresql" ? "jsonb" : "text");
+			continue;
+		}
+		if (field.type === "boolean") {
+			imports.add(dialect === "postgresql" ? "boolean" : "integer");
+			continue;
+		}
+		if (field.type === "date") {
+			imports.add(dialect === "postgresql" ? "timestamp" : "integer");
+			continue;
+		}
+		if (field.type === "number") {
+			imports.add("integer");
+			if (field.bigint && dialect === "postgresql") imports.add("bigint");
+		}
+	}
+	return [...imports].sort();
+}
+function generateVoidAuthDrizzleSchema(runtime, env = {}) {
+	const options = resolveSchemaOptions(runtime, env);
+	const schema = getAuthTables(options);
+	const migrationSchema = resolveVoidAuthMigrationSchema(runtime, env);
+	const idStrategy = resolveIdStrategy(options);
+	const defaultToVariable = /* @__PURE__ */ new Map();
+	const entries = Object.entries(schema).sort(([, left], [, right]) => (left.order ?? DEFAULT_TABLE_ORDER) - (right.order ?? DEFAULT_TABLE_ORDER));
+	for (const [defaultModelName] of entries) defaultToVariable.set(defaultModelName, `${sanitizeIdentifier(defaultModelName)}Table`);
+	const tableFactory = runtime.dialect === "postgresql" ? "pgTable" : "sqliteTable";
+	const importPath = runtime.dialect === "postgresql" ? "void/schema-pg" : "void/schema-d1";
+	const lines = [
+		"// Auto-generated by void — do not edit",
+		`import { ${collectCoreImports(runtime.dialect, schema, idStrategy).join(", ")} } from ${JSON.stringify(importPath)};`,
+		""
+	];
+	for (const [defaultModelName, table] of entries) {
+		const variableName = defaultToVariable.get(defaultModelName);
+		const fieldEntries = Object.entries(table.fields);
+		const renderedFields = [`  "id": ${createColumnDefinition(runtime.dialect, schema, idStrategy, defaultToVariable, "id", {
+			type: idStrategy === "serial" ? "number" : "string",
+			required: true
+		})},`, ...fieldEntries.map(([defaultFieldName, field]) => {
+			const actualFieldName = resolveFieldName(defaultFieldName, field);
+			return `  ${JSON.stringify(actualFieldName)}: ${createColumnDefinition(runtime.dialect, schema, idStrategy, defaultToVariable, defaultFieldName, field)},`;
+		})];
+		const indexedFields = fieldEntries.filter(([, field]) => field.index && !field.unique);
+		if (indexedFields.length > 0) lines.push(`export const ${variableName} = ${tableFactory}(${JSON.stringify(table.modelName)}, {`, ...renderedFields, `}, (table) => [`, ...indexedFields.map(([defaultFieldName, field]) => {
+			const actualFieldName = resolveFieldName(defaultFieldName, field);
+			return `  index(${JSON.stringify(`${table.modelName}_${actualFieldName}_idx`)}).on(table[${JSON.stringify(actualFieldName)}]),`;
+		}), `]);`);
+		else lines.push(`export const ${variableName} = ${tableFactory}(${JSON.stringify(table.modelName)}, {`, ...renderedFields, `});`);
+		lines.push("");
+	}
+	lines.push("export const schema = {");
+	for (const [defaultModelName] of entries) lines.push(`  ${JSON.stringify(defaultModelName)}: ${defaultToVariable.get(defaultModelName)},`);
+	lines.push("} as const;");
+	lines.push(`export const migrationSchema = ${JSON.stringify(migrationSchema, null, 2)} as const;`);
+	lines.push("");
+	return lines.join("\n") + "\n";
+}
+function resolveVoidAuthMigrationSchema(runtime, env = {}) {
+	const options = resolveSchemaOptions(runtime, env);
+	const schema = getSchema(options);
+	return {
+		dialect: runtime.dialect,
+		idStrategy: resolveIdStrategy(options),
+		tables: Object.entries(schema).sort(([, left], [, right]) => (left.order ?? DEFAULT_TABLE_ORDER) - (right.order ?? DEFAULT_TABLE_ORDER)).map(([name, table]) => ({
+			name,
+			order: table.order ?? DEFAULT_TABLE_ORDER,
+			fields: Object.fromEntries(Object.entries(table.fields).map(([fieldName, field]) => [fieldName, {
+				type: field.type,
+				required: field.required !== false,
+				unique: field.unique === true,
+				index: field.index === true,
+				bigint: field.bigint === true,
+				...field.references ? { references: {
+					table: field.references.model,
+					field: field.references.field,
+					...field.references.onDelete ? { onDelete: field.references.onDelete } : {}
+				} } : {}
+			}]))
+		}))
+	};
+}
+function generateVoidAuthDatabaseModule(options) {
+	const schemaImport = JSON.stringify(options.schemaImportPath);
+	const provider = options.dialect === "postgresql" ? "pg" : "sqlite";
+	return [
+		"// Auto-generated by void — do not edit",
+		`import { drizzleAdapter } from ${JSON.stringify(options.drizzleAdapterPath)};`,
+		`import { db as __voidDb } from "void/db";`,
+		`import { schema as __voidAuthSchema } from ${schemaImport};`,
+		"",
+		`export const __voidAuthDatabase = drizzleAdapter(__voidDb, { provider: ${JSON.stringify(provider)}, schema: __voidAuthSchema });`,
+		""
+	].join("\n");
+}
+//#endregion
+export { generateVoidAuthDrizzleSchema as n, resolveVoidAuthMigrationSchema as r, generateVoidAuthDatabaseModule as t };