@lontar/core 0.1.1 → 0.1.2

package/dist/client/index.d.ts

@@ -1,5 +1,6 @@
 import { A as ClientUploadField, C as ClientRichTextField, D as ClientTextField, E as ClientSlugField, O as ClientTextareaField, S as ClientRelationshipField, T as ClientSelectOption, _ as ClientDateField, a as WhereClause, b as ClientGlobal, c as SystemFieldName, d as UploadSystemFieldName, f as UploadSystemFields, g as ClientConfig, h as ClientCollection, i as Where, k as ClientUploadConfig, l as SystemFields, m as ClientCheckboxField, n as FilterOperator, o as WhereField, p as CLIENT_CONFIG_VERSION, r as SortItem, s as SYSTEM_FIELDS, t as FieldFilter, u as UPLOAD_SYSTEM_FIELDS, v as ClientEmailField, w as ClientSelectField, x as ClientNumberField, y as ClientField } from "../query-XQ3OKPOy.js";
 import { z } from "zod";
+export declare function isRichTextEmpty(val: unknown): boolean;
 /** Optional fields accept `null` and `undefined`, since their column is nullable. */
 export declare function clientFieldToZod(field: ClientField): z.ZodType;
 /**

package/dist/client/index.js

@@ -1 +1 @@
-export { r as CLIENT_CONFIG_VERSION, i as SYSTEM_FIELDS, a as UPLOAD_SYSTEM_FIELDS, t as clientFieldToZod, n as clientFieldsToZod } from "../zod-ClIdYqay.js";
+export { i as CLIENT_CONFIG_VERSION, a as SYSTEM_FIELDS, o as UPLOAD_SYSTEM_FIELDS, t as clientFieldToZod, n as clientFieldsToZod, r as isRichTextEmpty } from "../zod-DShD3pW7.js";

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 import { a as WhereClause, b as ClientGlobal, c as SystemFieldName, d as UploadSystemFieldName, f as UploadSystemFields, g as ClientConfig, h as ClientCollection, i as Where, l as SystemFields, n as FilterOperator, r as SortItem, s as SYSTEM_FIELDS, t as FieldFilter, u as UPLOAD_SYSTEM_FIELDS } from "./query-XQ3OKPOy.js";
 import { betterAuth } from "better-auth";
 import { Context, Hono } from "hono";
+import sharp from "sharp";
 interface BaseField {
   /** Shown in the admin. Defaults to the field name, humanized. */
   label?: string;
@@ -127,7 +128,20 @@ interface ProcessedImageResult {
   sizes: Record<string, ProcessedImageSize>;
 }
 export declare function isResizableImage(mimeType: string): boolean;
+export declare function isAnimatedMimeType(mimeType: string): boolean;
+export declare function getOrientedDimensions(meta: {
+  width?: number;
+  height?: number;
+  orientation?: number;
+  pageHeight?: number;
+}): {
+  width?: number;
+  height?: number;
+};
 export declare function formatVariantFilename(originalFilename: string, sizeName: string, format?: string): string;
+type SharpModule = typeof sharp;
+export declare function getSharp(): Promise<SharpModule>;
+export declare function setSharp(impl: SharpModule | null): void;
 export declare function processImage(args: {
   filename: string;
   buffer: Buffer;

package/dist/index.js

@@ -1,9 +1,8 @@
-import { a as UPLOAD_SYSTEM_FIELDS, i as SYSTEM_FIELDS, n as clientFieldsToZod } from "./zod-ClIdYqay.js";
+import { a as SYSTEM_FIELDS, n as clientFieldsToZod, o as UPLOAD_SYSTEM_FIELDS } from "./zod-DShD3pW7.js";
 import { betterAuth } from "better-auth";
 import { Hono } from "hono";
 import { bodyLimit } from "hono/body-limit";
 import { fileTypeFromBuffer } from "file-type";
-import sharp from "sharp";
 // src/config/collection.ts
 /**
 * Returns the config unchanged. It exists to infer `F`, which types InferDoc and
@@ -30,6 +29,12 @@ const RESERVED_SLUGS = /* @__PURE__ */ new Set([
 ]);
 const SYSTEM_FIELD_NAMES = new Set(SYSTEM_FIELDS);
 const UPLOAD_SYSTEM_FIELD_NAMES = new Set(UPLOAD_SYSTEM_FIELDS);
+const TEXT_LIKE_FIELD_TYPES = /* @__PURE__ */ new Set([
+	"text",
+	"textarea",
+	"email",
+	"select"
+]);
 const MAX_VARCHAR_LENGTH = 16383;
 var LontarConfigError = class extends Error {
 	issues;
@@ -51,9 +56,9 @@ function defineConfig(config) {
 function validateConfig(config) {
 	const issues = validateSecret(config.secret);
 	issues.push(...validatePagination("Config", config.pagination));
-	const collectionsResult = validateCollections(config.collections);
-	issues.push(...collectionsResult.issues);
-	issues.push(...validateGlobals(config.globals, collectionsResult.slugs));
+	const { issues: collectionIssues, collectionMap } = validateCollections(config.collections);
+	issues.push(...collectionIssues);
+	issues.push(...validateGlobals(config.globals, collectionMap));
 	issues.push(...validateStorage(config));
 	return issues;
 }
@@ -75,41 +80,48 @@ function validateCollections(collections) {
 		collectionMap.set(collection.slug, collection);
 		issues.push(...validateCollection(collection));
 	}
-	for (const collection of collections) issues.push(...validateUploadTargets(collection, collectionMap));
+	for (const collection of collections) issues.push(...validateFieldTargets(`Collection "${collection.slug}"`, collection.fields, collectionMap));
 	return {
 		issues,
-		slugs
+		collectionMap
 	};
 }
-function validateGlobals(globals, collectionSlugs) {
+function validateGlobals(globals, collectionMap) {
 	if (!globals) return [];
 	const issues = [];
 	const seen = /* @__PURE__ */ new Set();
 	for (const global of globals) {
 		if (seen.has(global.slug)) issues.push(`Global slug "${global.slug}" is used twice.`);
-		if (collectionSlugs.has(global.slug)) issues.push(`Global slug "${global.slug}" collides with a collection slug.`);
+		if (collectionMap.has(global.slug)) issues.push(`Global slug "${global.slug}" collides with a collection slug.`);
 		seen.add(global.slug);
 		issues.push(...validateGlobal(global));
+		issues.push(...validateFieldTargets(`Global "${global.slug}"`, global.fields, collectionMap));
 	}
 	return issues;
 }
-function validateUploadTargets(collection, collectionMap) {
+function validateFieldTargets(where, fields, collectionMap) {
 	const issues = [];
-	for (const [name, field] of Object.entries(collection.fields)) {
-		if (field.type !== "upload") continue;
-		const target = collectionMap.get(field.relationTo);
-		if (!target) issues.push(`Collection "${collection.slug}": upload field "${name}" refers to unknown collection "${field.relationTo}".`);
-		else if (!target.upload) issues.push(`Collection "${collection.slug}": upload field "${name}" refers to collection "${field.relationTo}" which does not have upload enabled.`);
-	}
+	for (const [name, field] of Object.entries(fields)) if (field.type === "upload") issues.push(...validateUploadTarget(where, name, field, collectionMap));
+	else if (field.type === "relationship") issues.push(...validateRelationshipTarget(where, name, field, collectionMap));
 	return issues;
 }
+function validateUploadTarget(where, name, field, collectionMap) {
+	const target = collectionMap.get(field.relationTo);
+	if (!target) return [`${where}: upload field "${name}" refers to unknown collection "${field.relationTo}".`];
+	if (!target.upload) return [`${where}: upload field "${name}" refers to collection "${field.relationTo}" which does not have upload enabled.`];
+	return [];
+}
+function validateRelationshipTarget(where, name, field, collectionMap) {
+	if (!collectionMap.has(field.relationTo)) return [`${where}: relationship field "${name}" refers to unknown collection "${field.relationTo}".`];
+	return [];
+}
 function validateCollection(collection) {
 	const where = `Collection "${collection.slug}"`;
 	const isUpload = Boolean(collection.upload);
 	return [
 		...validateSlug(collection.slug, "Collection"),
 		...Object.keys(collection.fields).flatMap((name) => validateFieldName(where, name, isUpload)),
-		...Object.entries(collection.fields).flatMap(([name, field]) => validateField(where, name, field)),
+		...Object.entries(collection.fields).flatMap(([name, field]) => validateField(where, name, field, collection.fields)),
 		...validatePagination(where, collection.pagination),
 		...validateAdmin(where, collection),
 		...validateAccess(where, collection)
@@ -132,13 +144,22 @@ function validateGlobal(global) {
 	return [
 		...validateSlug(global.slug, "Global"),
 		...Object.keys(global.fields).flatMap((name) => validateFieldName(where, name)),
-		...Object.entries(global.fields).flatMap(([name, field]) => validateField(where, name, field)),
+		...Object.entries(global.fields).flatMap(([name, field]) => validateField(where, name, field, global.fields)),
 		...validateGlobalAccess(where, global)
 	];
 }
-function validateField(where, name, field) {
+function validateField(where, name, field, fields) {
 	if (field.type === "text") return validateTextField(where, name, field);
 	if (field.type === "textarea") return validateTextareaField(where, name, field);
+	if (field.type === "slug") return validateSlugField(where, name, field, fields);
+	return [];
+}
+function validateSlugField(where, name, field, fields) {
+	if (field.from === void 0) return [];
+	if (field.from === name) return [`${where}: slug field "${name}" cannot refer to itself in \`from\`.`];
+	const sourceField = fields[field.from];
+	if (!sourceField) return [`${where}: slug field "${name}" \`from\` refers to unknown field "${field.from}".`];
+	if (!TEXT_LIKE_FIELD_TYPES.has(sourceField.type)) return [`${where}: slug field "${name}" \`from\` must refer to a text-like field, but "${field.from}" is of type "${sourceField.type}".`];
 	return [];
 }
 function validateTextField(where, name, field) {
@@ -349,10 +370,18 @@ function clientLabels({ slug, labels = {} }) {
 		plural
 	};
 }
+function isTextLike(type) {
+	return type === "text" || type === "email" || type === "slug";
+}
+function resolveDefaultTitle(fields, upload) {
+	const textLikeField = fields.find((field) => isTextLike(field.type));
+	if (textLikeField) return textLikeField.name;
+	if (upload) return "filename";
+	return "id";
+}
 function clientAdmin(collection, fields) {
 	const { admin = {}, upload } = collection;
-	const defaultTitle = upload ? "filename" : "id";
-	const useAsTitle = admin.useAsTitle ?? defaultTitle;
+	const useAsTitle = admin.useAsTitle ?? resolveDefaultTitle(fields, Boolean(upload));
 	const others = fields.map((field) => field.name).filter((name) => name !== useAsTitle);
 	return {
 		useAsTitle,
@@ -900,6 +929,22 @@ const FORMAT_TO_MIME = {
 function isResizableImage(mimeType) {
 	return RESIZABLE_MIME_TYPES.has(mimeType.toLowerCase());
 }
+function isAnimatedMimeType(mimeType) {
+	const lower = mimeType.toLowerCase();
+	return lower === "image/gif" || lower === "image/webp";
+}
+function getOrientedDimensions(meta) {
+	if (meta.width === void 0 || meta.height === void 0) return {
+		width: meta.width,
+		height: meta.height
+	};
+	const isTransposed = typeof meta.orientation === "number" && meta.orientation >= 5;
+	const rawHeight = meta.pageHeight ?? meta.height;
+	return {
+		width: isTransposed ? rawHeight : meta.width,
+		height: isTransposed ? meta.width : rawHeight
+	};
+}
 function formatVariantFilename(originalFilename, sizeName, format) {
 	const lastDot = originalFilename.lastIndexOf(".");
 	const base = lastDot > 0 ? originalFilename.slice(0, lastDot) : originalFilename;
@@ -910,9 +955,25 @@ function resolveMimeType(originalMime, format) {
 	if (format && FORMAT_TO_MIME[format]) return FORMAT_TO_MIME[format];
 	return originalMime;
 }
-async function resizeVariant(buffer, name, config, originalFilename, originalMimeType) {
+let cachedSharp = null;
+async function getSharp() {
+	if (cachedSharp) return cachedSharp;
 	try {
-		let pipeline = sharp(buffer).rotate();
+		const mod = await import("sharp");
+		cachedSharp = mod.default ?? mod;
+		return cachedSharp;
+	} catch (cause) {
+		throw new Error("The \"sharp\" image processing library is required to process images, but failed to load.", { cause });
+	}
+}
+function setSharp(impl) {
+	cachedSharp = impl;
+}
+async function resizeVariant(sharp, buffer, name, config, originalFilename, originalMimeType) {
+	try {
+		const targetMimeType = resolveMimeType(originalMimeType, config.format);
+		const isAnimated = isAnimatedMimeType(originalMimeType) && isAnimatedMimeType(targetMimeType);
+		let pipeline = sharp(buffer, isAnimated ? { animated: true } : void 0).rotate();
 		pipeline = pipeline.resize({
 			width: config.width,
 			height: config.height,
@@ -921,16 +982,17 @@ async function resizeVariant(buffer, name, config, originalFilename, originalMim
 		});
 		if (config.format) pipeline = pipeline.toFormat(config.format, { quality: config.quality });
 		const resizedBuffer = await pipeline.toBuffer();
-		const meta = await sharp(resizedBuffer).metadata();
-		const mimeType = resolveMimeType(originalMimeType, config.format);
+		const meta = await sharp(resizedBuffer, isAnimated ? { animated: true } : void 0).metadata();
+		const filename = formatVariantFilename(originalFilename, name, config.format);
+		const { width, height } = getOrientedDimensions(meta);
 		return {
 			name,
-			filename: formatVariantFilename(originalFilename, name, config.format),
+			filename,
 			buffer: resizedBuffer,
-			width: meta.width,
-			height: meta.height,
+			width,
+			height,
 			filesize: resizedBuffer.length,
-			mimeType
+			mimeType: targetMimeType
 		};
 	} catch (err) {
 		if (err instanceof InvalidImageError) throw err;
@@ -948,17 +1010,19 @@ async function processImage(args) {
 		},
 		sizes: {}
 	};
+	const sharp = await getSharp();
 	let meta;
 	try {
-		meta = await sharp(buffer).metadata();
+		meta = await sharp(buffer, { animated: isAnimatedMimeType(mimeType) }).metadata();
 	} catch {
 		throw new InvalidImageError("Invalid image");
 	}
+	const { width, height } = getOrientedDimensions(meta);
 	const original = {
 		filename,
 		buffer,
-		width: meta.width,
-		height: meta.height,
+		width,
+		height,
 		filesize: buffer.length,
 		mimeType
 	};
@@ -967,7 +1031,7 @@ async function processImage(args) {
 		sizes: {}
 	};
 	const processedSizes = {};
-	for (const [name, config] of Object.entries(sizes)) processedSizes[name] = await resizeVariant(buffer, name, config, filename, mimeType);
+	for (const [name, config] of Object.entries(sizes)) processedSizes[name] = await resizeVariant(sharp, buffer, name, config, filename, mimeType);
 	return {
 		original,
 		sizes: processedSizes
@@ -2622,4 +2686,4 @@ function getLontar(config) {
 	};
 	return Promise.resolve(client);
 }
-export { AccessDeniedError, DEFAULT_LIMIT, DEFAULT_MAX_FILE_SIZE, DatabaseError, InvalidImageError, LontarConfigError, MAX_LIMIT, NotFoundError, SYSTEM_FIELDS, StorageUploadError, UPLOAD_SYSTEM_FIELDS, UniqueConstraintError, ValidationError, accessDenied, checkAccess, collection, countTotalUsers, createLontar, createOperation, createUserWithCredential, defaultAccess, defineConfig, deleteMedia, deleteOperation, fields, findByIDOperation, findGlobalOperation, findOperation, formatUniqueConstraintError, formatVariantFilename, getLontar, global, isResizableImage, parseDepth, parseSort, parseWhere, parseWhereFromSearchParams, populateDoc, populateDocs, processImage, runAfterChangeHooks, runAfterReadHooks, runBeforeChangeHooks, toClientCollection, toClientConfig, toClientGlobal, updateGlobalOperation, updateOperation, uploadMedia, validateWhere };
+export { AccessDeniedError, DEFAULT_LIMIT, DEFAULT_MAX_FILE_SIZE, DatabaseError, InvalidImageError, LontarConfigError, MAX_LIMIT, NotFoundError, SYSTEM_FIELDS, StorageUploadError, UPLOAD_SYSTEM_FIELDS, UniqueConstraintError, ValidationError, accessDenied, checkAccess, collection, countTotalUsers, createLontar, createOperation, createUserWithCredential, defaultAccess, defineConfig, deleteMedia, deleteOperation, fields, findByIDOperation, findGlobalOperation, findOperation, formatUniqueConstraintError, formatVariantFilename, getLontar, getOrientedDimensions, getSharp, global, isAnimatedMimeType, isResizableImage, parseDepth, parseSort, parseWhere, parseWhereFromSearchParams, populateDoc, populateDocs, processImage, runAfterChangeHooks, runAfterReadHooks, runBeforeChangeHooks, setSharp, toClientCollection, toClientConfig, toClientGlobal, updateGlobalOperation, updateOperation, uploadMedia, validateWhere };

package/dist/{zod-ClIdYqay.js → zod-DShD3pW7.js}

@@ -24,13 +24,26 @@ const CLIENT_CONFIG_VERSION = 1;
 // src/client/zod.ts
 const MAX_INT_32 = 2147483647;
 const DEFAULT_STRING_MAX_LENGTH = 255;
+function isRichTextEmpty(val) {
+	if (!val || typeof val !== "object") return true;
+	const doc = val;
+	if (typeof doc.text === "string") return doc.text.trim().length === 0;
+	if (Array.isArray(doc.content)) {
+		if (doc.content.length === 0) return true;
+		return doc.content.every((child) => isRichTextEmpty(child));
+	}
+	if (doc.type && doc.type !== "doc" && doc.type !== "paragraph") return false;
+	return true;
+}
 const zodByType = {
 	text: (field) => {
-		const minLength = Math.max(field.minLength ?? 0, field.required ? 1 : 0);
 		const maxLength = field.maxLength ?? DEFAULT_STRING_MAX_LENGTH;
-		let schema = z.string();
-		if (minLength > 0) schema = schema.min(minLength);
-		schema = schema.max(maxLength);
+		if (field.required) {
+			const minLength = Math.max(field.minLength ?? 1, 1);
+			return z.string().min(minLength).max(maxLength);
+		}
+		const schema = z.string().max(maxLength);
+		if (field.minLength !== void 0 && field.minLength > 0) return schema.min(field.minLength).or(z.literal(""));
 		return schema;
 	},
 	number: (field) => {
@@ -41,10 +54,15 @@ const zodByType = {
 		return schema;
 	},
 	textarea: (field) => {
-		const minLength = Math.max(field.minLength ?? 0, field.required ? 1 : 0);
+		if (field.required) {
+			const minLength = Math.max(field.minLength ?? 1, 1);
+			let schema = z.string().min(minLength);
+			if (field.maxLength !== void 0) schema = schema.max(field.maxLength);
+			return schema;
+		}
 		let schema = z.string();
-		if (minLength > 0) schema = schema.min(minLength);
 		if (field.maxLength !== void 0) schema = schema.max(field.maxLength);
+		if (field.minLength !== void 0 && field.minLength > 0) return schema.min(field.minLength).or(z.literal(""));
 		return schema;
 	},
 	email: (field) => {
@@ -75,7 +93,7 @@ const zodByType = {
 	},
 	richText: (field) => {
 		const base = z.record(z.string(), z.unknown());
-		if (field.required) return base.refine((val) => val && Object.keys(val).length > 0, { message: "Rich text content is required" });
+		if (field.required) return base.refine((val) => !isRichTextEmpty(val), { message: "Rich text content is required" });
 		return base;
 	},
 	relationship: (field) => {
@@ -103,4 +121,4 @@ function clientFieldToZod(field) {
 function clientFieldsToZod(fields) {
 	return z.object(Object.fromEntries(fields.map((field) => [field.name, clientFieldToZod(field)])));
 }
-export { UPLOAD_SYSTEM_FIELDS as a, SYSTEM_FIELDS as i, clientFieldsToZod as n, CLIENT_CONFIG_VERSION as r, clientFieldToZod as t };
+export { SYSTEM_FIELDS as a, CLIENT_CONFIG_VERSION as i, clientFieldsToZod as n, UPLOAD_SYSTEM_FIELDS as o, isRichTextEmpty as r, clientFieldToZod as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lontar/core",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Lontar core: config, fields, validation, hooks, access control, REST API (Hono) and Local API.",
   "keywords": [
     "lontar",