ajo-kit 0.1.0

package/dist/chunks/constants-5Eu0naK3.js

@@ -0,0 +1,168 @@
+//#region packages/ajo-kit/src/constants.ts
+/** HTTP-aware error serialized by loaders, actions, and API handlers. */
+var Failure = class extends Error {
+	status;
+	constructor(status, message) {
+		super(message);
+		this.status = status;
+	}
+	toJSON() {
+		return {
+			message: mask(this.status, this.message),
+			status: this.status,
+			...!production() && false
+		};
+	}
+};
+/** 404 error for missing routes or resources. */
+var Missing = class extends Failure {
+	constructor(message = "Page not found") {
+		super(404, message);
+	}
+};
+/** 403 error for authenticated users without enough access. */
+var Forbidden = class extends Failure {
+	constructor(message = "Access denied") {
+		super(403, message);
+	}
+};
+/** 401 error for requests that need authentication. */
+var Denied = class extends Failure {
+	constructor(message = "Authentication required") {
+		super(401, message);
+	}
+};
+/** 400 validation error carrying field-level messages. */
+var Invalid = class extends Failure {
+	fields;
+	constructor(fields, message = "Validation failed") {
+		super(400, message);
+		this.fields = fields;
+	}
+	toJSON() {
+		return {
+			message: mask(this.status, this.message),
+			status: this.status,
+			fields: this.fields,
+			...!production() && false
+		};
+	}
+};
+var production = () => process.env.NODE_ENV === "production";
+var mask = (status, message) => production() && status >= 500 ? "Internal Server Error" : message;
+var config = (message) => {
+	if (production()) console.error(`[security] ${message}`);
+	return new Failure(500, message);
+};
+var code = (error) => {
+	if (!error || typeof error !== "object") return 500;
+	const value = error.status ?? error.statusCode;
+	return Number.isInteger(value) && value >= 400 && value <= 599 ? value : 500;
+};
+var message = (error, status) => {
+	if (status === 413) return "Content Too Large";
+	if (error instanceof Error && error.message) return error.message;
+	return status < 500 ? "Request failed" : "Unknown error";
+};
+/** Converts any thrown value into a framework Failure. */
+function normalize(error) {
+	if (error instanceof Failure) return error;
+	const status = code(error);
+	return new Failure(status, message(error, status));
+}
+/** Returns route ancestor keys from outermost to innermost. */
+var ancestors = (segments) => segments.map((_, i) => segments.slice(0, i + 1).join("/"));
+/** Pushes a browser URL and asks the client router to navigate. */
+var navigate = (to) => {
+	globalThis.history?.pushState({}, "", to);
+	globalThis.dispatchEvent?.(new CustomEvent("ajo:navigate"));
+};
+/** Returns true when a request expects JSON route/action data. */
+var ajax = (req) => !!req.headers.accept?.includes("application/json");
+/** Returns true when a request targets the /api route namespace. */
+var api = (req) => req.path.startsWith("/api/");
+var enabled = (value) => value === "1" || value?.toLowerCase() === "true";
+var proxy = () => enabled(process.env.TRUST_PROXY);
+var first = (value) => Array.isArray(value) ? value[0] : value;
+var address = (value) => {
+	const raw = value.trim().replace(/^\[/, "").replace(/\]$/, "").replace(/^::ffff:/, "");
+	return raw === "::1" || raw === "127.0.0.1" ? "localhost" : raw;
+};
+var ipv4 = (value) => {
+	const parts = value.split(".");
+	return parts.length === 4 && parts.every((part) => {
+		if (!/^\d{1,3}$/.test(part)) return false;
+		const number = Number(part);
+		return number >= 0 && number <= 255;
+	});
+};
+var ipv6 = (value) => value.includes(":") && /^[0-9a-f:.]+$/i.test(value);
+var local = (host) => {
+	try {
+		return address(new URL(`http://${host}`).hostname) === "localhost";
+	} catch {
+		return false;
+	}
+};
+var forwarded = (header) => {
+	const value = first(header);
+	if (!value) return;
+	const addr = address(value.split(",")[0]);
+	if (addr === "localhost" || ipv4(addr) || ipv6(addr)) return addr;
+};
+/** Resolves the client IP, honoring TRUST_PROXY for forwarded headers. */
+var ip = (req) => {
+	const raw = proxy() ? forwarded(req.headers["x-forwarded-for"]) ?? req.socket?.remoteAddress : req.socket?.remoteAddress;
+	return raw ? address(raw) : "unknown";
+};
+/** Resolves the trusted app origin from APP_URL or the request host. */
+var origin = (req) => {
+	const configured = process.env.APP_URL;
+	if (configured) try {
+		const url = new URL(configured);
+		if (url.protocol !== "http:" && url.protocol !== "https:") throw new Error();
+		return url.origin;
+	} catch {
+		throw config("Invalid APP_URL");
+	}
+	const host = req.headers.host;
+	if (!host) throw new Failure(400, "Missing Host header");
+	if (production() && !local(host)) throw config("APP_URL is required in production");
+	const forwarded = first(req.headers["x-forwarded-proto"])?.split(",")[0]?.trim();
+	const protocol = proxy() && (forwarded === "http" || forwarded === "https") ? forwarded : "http";
+	try {
+		return new URL(`${protocol}://${host}`).origin;
+	} catch {
+		throw new Failure(400, "Invalid Host header");
+	}
+};
+/** Builds parent/deferred links for a loader chain. */
+function links(count) {
+	const chain = [];
+	for (let depth = 0; depth < count; depth++) {
+		let resolve;
+		let reject;
+		const promise = new Promise((res, rej) => {
+			resolve = res;
+			reject = rej;
+		});
+		const parent = async () => Object.assign({}, ...await Promise.all(chain.slice(0, depth).map((link) => link.deferred.promise)));
+		chain.push({
+			parent,
+			deferred: {
+				promise,
+				resolve,
+				reject
+			}
+		});
+	}
+	return chain;
+}
+/** Formats an ISO date for the current locale with compact defaults. */
+var date = (iso, options) => new Date(iso).toLocaleDateString(void 0, options ?? {
+	month: "short",
+	day: "numeric",
+	year: "numeric"
+});
+//#endregion
+export { Missing as a, api as c, links as d, navigate as f, Invalid as i, date as l, origin as m, Failure as n, ajax as o, normalize as p, Forbidden as r, ancestors as s, Denied as t, ip as u };

package/dist/chunks/discover-D-b8Pqm8.js

@@ -0,0 +1,34 @@
+import { join } from "node:path";
+import { readFileSync, readdirSync } from "node:fs";
+//#region packages/ajo-kit/src/discover.ts
+function discover(root = process.cwd()) {
+	const modules = join(root, "node_modules");
+	const plugins = [];
+	let entries;
+	try {
+		entries = readdirSync(modules);
+	} catch {
+		return plugins;
+	}
+	for (const entry of entries) {
+		if (!entry.startsWith("ajo-") || entry === "ajo-kit") continue;
+		const dir = join(modules, entry);
+		let pkg;
+		try {
+			pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+		} catch {
+			continue;
+		}
+		if (!pkg.kit) continue;
+		plugins.push({
+			name: pkg.name,
+			path: dir,
+			...pkg.kit,
+			...pkg.kit.migrations && { migrations: join(dir, pkg.kit.migrations) },
+			...pkg.kit.commands && { commands: join(dir, pkg.kit.commands) }
+		});
+	}
+	return plugins;
+}
+//#endregion
+export { discover as t };

package/dist/chunks/headers-BDszzwLw.js

@@ -0,0 +1,23 @@
+//#region packages/ajo-kit/src/headers.ts
+var https = () => {
+	if (process.env.NODE_ENV !== "production" || !process.env.APP_URL) return false;
+	try {
+		return new URL(process.env.APP_URL).protocol === "https:";
+	} catch {
+		return false;
+	}
+};
+/** Security headers shared by dynamic SSR responses and static assets. */
+var security = () => ({
+	"X-Content-Type-Options": "nosniff",
+	"Referrer-Policy": "strict-origin-when-cross-origin",
+	"Permissions-Policy": "camera=(), microphone=(), geolocation=(), payment=(), usb=()",
+	"Content-Security-Policy": "frame-ancestors 'none'",
+	...https() && { "Strict-Transport-Security": "max-age=31536000; includeSubDomains" }
+});
+/** Writes headers, optionally preserving values already set downstream. */
+var set = (res, values, missing = false) => {
+	for (const [key, value] of Object.entries(values)) if (!missing || !res.hasHeader(key)) res.setHeader(key, value);
+};
+//#endregion
+export { set as n, security as t };

package/dist/chunks/migrate-C9Iytqx4.js

@@ -0,0 +1,89 @@
+import { t as discover } from "./discover-D-b8Pqm8.js";
+import { pathToFileURL } from "node:url";
+import * as path from "node:path";
+import { existsSync, promises } from "node:fs";
+import { FileMigrationProvider, Migrator } from "kysely/migration";
+//#region packages/ajo-kit/src/migrate.ts
+var extensions = [
+	".js",
+	".ts",
+	".mjs",
+	".mts",
+	".cjs",
+	".cts"
+];
+var pattern = /^(\d{4})_[a-z0-9]+(?:_[a-z0-9]+)*$/;
+var file = (name) => !name.includes(".d.") && extensions.some((extension) => name.endsWith(extension));
+function validate(id, names) {
+	for (const [index, name] of names.entries()) {
+		const sequence = pattern.exec(name)?.[1];
+		const expected = String(index + 1).padStart(4, "0");
+		if (sequence !== expected) throw new Error(`${id} migrations must be a contiguous sequence starting at 0001; expected ${expected}_*, found ${name}`);
+	}
+}
+function local(id, files) {
+	const names = files.filter(file).map((name) => name.slice(0, name.lastIndexOf("."))).sort();
+	if (new Set(names).size !== names.length) throw new Error(`${id} has duplicate migration filenames`);
+	validate(id, names);
+	return names;
+}
+function migrationFile(files, name) {
+	const safe = name.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+	if (!safe) throw new Error("Migration name must contain a letter or number");
+	const number = local("project", files).length + 1;
+	if (number > 9999) throw new Error("Migration sequence exhausted");
+	return `${String(number).padStart(4, "0")}_${safe}.ts`;
+}
+async function load(source) {
+	const names = local(source.id, await promises.readdir(source.folder));
+	const migrations = await new FileMigrationProvider({
+		fs: promises,
+		path,
+		migrationFolder: source.folder,
+		import: (file) => import(pathToFileURL(file).href)
+	}).getMigrations();
+	const incomplete = names.filter((name) => typeof migrations[name]?.up !== "function" || typeof migrations[name]?.down !== "function");
+	if (incomplete.length) throw new Error(`${source.id} migrations must export up() and down(): ${incomplete.join(", ")}`);
+	return migrations;
+}
+async function merge(sources) {
+	const merged = {};
+	const ids = /* @__PURE__ */ new Set();
+	for (const source of sources) {
+		if (ids.has(source.id)) throw new Error(`Duplicate migration source "${source.id}"`);
+		ids.add(source.id);
+		for (const [name, migration] of Object.entries(await load(source))) {
+			const qualified = `${source.id}/${name}`;
+			merged[qualified] = migration;
+		}
+	}
+	return merged;
+}
+function migrator(instance, root = process.cwd()) {
+	const sources = discover(root).filter((plugin) => plugin.migrations).sort((left, right) => left.name.localeCompare(right.name)).map((plugin) => ({
+		folder: plugin.migrations,
+		id: `plugin/${plugin.name}`
+	}));
+	const project = path.join(root, "db/migrations");
+	if (existsSync(project)) sources.push({
+		folder: project,
+		id: "project"
+	});
+	return new Migrator({
+		db: instance,
+		allowUnorderedMigrations: true,
+		provider: { async getMigrations() {
+			return merge(sources);
+		} }
+	});
+}
+async function migrationStatus(instance, root = process.cwd()) {
+	const migrations = await migrator(instance, root).getMigrations();
+	if (!await instance.selectFrom("sqlite_master").select("name").where("type", "=", "table").where("name", "=", "kysely_migration").executeTakeFirst()) return migrations;
+	const available = new Set(migrations.map((migration) => migration.name));
+	const missing = (await instance.selectFrom("kysely_migration").select("name").execute()).map((migration) => migration.name).filter((name) => !available.has(name)).sort();
+	if (missing.length) throw new Error(`Migration history references missing migrations: ${missing.join(", ")}`);
+	return migrations;
+}
+//#endregion
+export { migrationFile, migrationStatus, migrator };