permdock 0.0.0 → 0.2.0

package/dist/generate-CH7ThJ14.js

@@ -0,0 +1,173 @@
+import { t as byCodePoint } from "./compare-pfyVnBjE.js";
+//#region src/cli/generate.ts
+const IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/u;
+const MAX_DEPTH = 6;
+function isSchemaKind(value) {
+	return value === "zod" || value === "valibot" || value === "arktype";
+}
+function schemaImport(kind) {
+	switch (kind) {
+		case "zod": return "import { z } from 'zod'";
+		case "valibot": return "import * as v from 'valibot'";
+		case "arktype": return "import { type } from 'arktype'";
+		default: return kind;
+	}
+}
+function emptySchema(kind) {
+	return schemaExpression(kind, { type: "object" });
+}
+function propertyKey(name) {
+	return IDENTIFIER.test(name) ? name : JSON.stringify(name);
+}
+function isRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function literalEnum(schema) {
+	const values = schema["enum"];
+	if (!Array.isArray(values) || values.length === 0 || !values.every((value) => typeof value === "string")) return;
+	return values;
+}
+function schemaType(schema) {
+	const type = schema["type"];
+	if (typeof type === "string") return type;
+	if (Array.isArray(type)) {
+		const named = type.filter((item) => item !== "null");
+		return named.length === 1 && typeof named[0] === "string" ? named[0] : void 0;
+	}
+	return isRecord(schema["properties"]) ? "object" : void 0;
+}
+function zodOf(schema, resolve, depth) {
+	const node = resolve(schema);
+	const values = literalEnum(node);
+	if (values !== void 0) return `z.enum(${JSON.stringify(values)})`;
+	const type = depth > MAX_DEPTH ? void 0 : schemaType(node);
+	if (type === void 0) return "z.unknown()";
+	switch (type) {
+		case "string": return "z.string()";
+		case "number": return "z.number()";
+		case "integer": return "z.number().int()";
+		case "boolean": return "z.boolean()";
+		case "array": return `z.array(${isRecord(node["items"]) ? zodOf(node["items"], resolve, depth + 1) : "z.unknown()"})`;
+		case "object": {
+			const required = new Set(Array.isArray(node["required"]) ? node["required"] : []);
+			const properties = isRecord(node["properties"]) ? node["properties"] : {};
+			const fields = Object.entries(properties).filter((entry) => isRecord(entry[1])).map(([name, child]) => {
+				const expression = zodOf(child, resolve, depth + 1);
+				return `${propertyKey(name)}: ${required.has(name) ? expression : `${expression}.optional()`}`;
+			});
+			return `z.object({${fields.length === 0 ? "" : ` ${fields.join(", ")} `}})`;
+		}
+		default: return "z.unknown()";
+	}
+}
+function valibotOf(schema, resolve, depth) {
+	const node = resolve(schema);
+	const values = literalEnum(node);
+	if (values !== void 0) return `v.picklist(${JSON.stringify(values)})`;
+	const type = depth > MAX_DEPTH ? void 0 : schemaType(node);
+	if (type === void 0) return "v.unknown()";
+	switch (type) {
+		case "string": return "v.string()";
+		case "number": return "v.number()";
+		case "integer": return "v.pipe(v.number(), v.integer())";
+		case "boolean": return "v.boolean()";
+		case "array": return `v.array(${isRecord(node["items"]) ? valibotOf(node["items"], resolve, depth + 1) : "v.unknown()"})`;
+		case "object": {
+			const required = new Set(Array.isArray(node["required"]) ? node["required"] : []);
+			const properties = isRecord(node["properties"]) ? node["properties"] : {};
+			const fields = Object.entries(properties).filter((entry) => isRecord(entry[1])).map(([name, child]) => {
+				const expression = valibotOf(child, resolve, depth + 1);
+				return `${propertyKey(name)}: ${required.has(name) ? expression : `v.optional(${expression})`}`;
+			});
+			return `v.object({${fields.length === 0 ? "" : ` ${fields.join(", ")} `}})`;
+		}
+		default: return "v.unknown()";
+	}
+}
+/** An arktype definition: a string keyword or an object literal. */
+function arktypeOf(schema, resolve, depth) {
+	const node = resolve(schema);
+	const values = literalEnum(node);
+	if (values !== void 0) return JSON.stringify(values.map((value) => `'${value.replaceAll("'", "\\'")}'`).join(" | "));
+	const type = depth > MAX_DEPTH ? void 0 : schemaType(node);
+	if (type === void 0) return "'unknown'";
+	switch (type) {
+		case "string": return "'string'";
+		case "number": return "'number'";
+		case "integer": return "'number.integer'";
+		case "boolean": return "'boolean'";
+		case "array": {
+			if (!isRecord(node["items"])) return "'unknown[]'";
+			const item = arktypeOf(node["items"], resolve, depth + 1);
+			return item.startsWith("'") && !item.includes("|") ? `'${item.slice(1, -1)}[]'` : `[${item}, '[]']`;
+		}
+		case "object": {
+			const required = new Set(Array.isArray(node["required"]) ? node["required"] : []);
+			const properties = isRecord(node["properties"]) ? node["properties"] : {};
+			const fields = Object.entries(properties).filter((entry) => isRecord(entry[1])).map(([name, child]) => `${JSON.stringify(required.has(name) ? name : `${name}?`)}: ${arktypeOf(child, resolve, depth + 1)}`);
+			return `{${fields.length === 0 ? "" : ` ${fields.join(", ")} `}}`;
+		}
+		default: return "'unknown'";
+	}
+}
+/**
+* A validator expression for a JSON Schema object. Only the portable core
+* (primitives, enums of strings, arrays, objects with `required`) is
+* translated; anything else becomes the validator's `unknown`.
+*/
+function schemaExpression(kind, schema, resolve = (node) => node) {
+	switch (kind) {
+		case "zod": return zodOf(schema, resolve, 0);
+		case "valibot": return valibotOf(schema, resolve, 0);
+		case "arktype": return `type(${arktypeOf(schema, resolve, 0)})`;
+		default: return kind;
+	}
+}
+function renderList(value, indent) {
+	if (Array.isArray(value)) return JSON.stringify(value);
+	return JSON.stringify(value, null, 2).replaceAll("\n", `\n${indent}`);
+}
+function renderResource(resource, indent) {
+	const inner = `${indent}  `;
+	const options = [
+		`${inner}id: '${(resource.id ?? "id").replaceAll("\\", "\\\\").replaceAll("'", "\\'")}',`,
+		`${inner}actions: ${renderList(resource.actions, inner)},`,
+		`${inner}collection: ${renderList(resource.collection, inner)},`
+	].join("\n");
+	return `${resource.schema === void 0 ? "resource({" : `resource(${resource.schema}, {`}\n${options}\n${indent}})`;
+}
+function insert(trie, resource) {
+	let node = trie;
+	for (const [index, segment] of resource.path.entries()) {
+		if (index === resource.path.length - 1) {
+			node.set(segment, resource);
+			return;
+		}
+		const next = node.get(segment);
+		if (next instanceof Map) node = next;
+		else {
+			const created = /* @__PURE__ */ new Map();
+			node.set(segment, created);
+			node = created;
+		}
+	}
+}
+function renderTrie(trie, indent) {
+	return [...trie.entries()].toSorted(([a], [b]) => byCodePoint(a, b)).map(([segment, value]) => value instanceof Map ? `${indent}${propertyKey(segment)}: {\n${renderTrie(value, `${indent}  `)}\n${indent}},` : `${indent}${propertyKey(segment)}: ${renderResource(value, indent)},`).join("\n");
+}
+/** A deterministic `definePermissions()` module with a `// @generated` header. */
+function emitPermissionsModule(input) {
+	const trie = /* @__PURE__ */ new Map();
+	for (const resource of input.resources) insert(trie, resource);
+	const imports = ["import { definePermissions, resource } from 'permdock'", ...input.schema === void 0 ? [] : [schemaImport(input.schema)]];
+	const extras = Object.entries(input.exports ?? {}).map(([name, value]) => `export const ${name} = ${JSON.stringify(value, null, 2)} as const\n\n`);
+	return `// @generated by permdock ${input.generator}
+${imports.join("\n")}
+
+${extras.join("")}export const permissions = definePermissions({
+${renderTrie(trie, "  ")}
+})
+`;
+}
+//#endregion
+export { schemaExpression as i, emptySchema as n, isSchemaKind as r, emitPermissionsModule as t };