@danceroutine/tango-resources 1.11.3 → 1.11.5

package/dist/index.js

@@ -1,1014 +1,11 @@
-import { t as __exportAll } from "./chunk-D7D4PA-g.js";
-import { _ as OffsetPaginator, a as ListCreateAPIView, b as context_exports, c as ListAPIView, d as RetrieveModelMixin, f as CreateModelMixin, g as inferModelFieldParsers, h as APIView, i as RetrieveUpdateAPIView, l as DestroyModelMixin, m as GenericAPIView, n as RetrieveUpdateDestroyAPIView, o as RetrieveAPIView, p as ListModelMixin, r as RetrieveDestroyAPIView, s as CreateAPIView, t as view_exports, u as UpdateModelMixin, v as OffsetPaginationInput, x as RequestContext, y as BasePaginator } from "./view-C9B5Lln3.js";
-import { HttpErrorFactory, NotFoundError, TangoResponse, getLogger } from "@danceroutine/tango-core";
-import { ManyToManyRelatedManager, Q } from "@danceroutine/tango-orm";
-import { z } from "zod";
-//#region src/filters/internal/InternalFilterType.ts
-const InternalFilterType = {
-	SCALAR: "scalar",
-	ILIKE: "ilike",
-	RANGE: "range",
-	IN: "in",
-	CUSTOM: "custom"
-};
-//#endregion
-//#region src/filters/internal/InternalFilterLookup.ts
-const InternalFilterLookup = {
-	EXACT: "exact",
-	LT: "lt",
-	LTE: "lte",
-	GT: "gt",
-	GTE: "gte",
-	IN: "in",
-	ISNULL: "isnull",
-	CONTAINS: "contains",
-	ICONTAINS: "icontains",
-	STARTSWITH: "startswith",
-	ISTARTSWITH: "istartswith",
-	ENDSWITH: "endswith",
-	IENDSWITH: "iendswith"
-};
-//#endregion
-//#region src/filters/FilterSet.ts
-const FILTER_LOOKUPS = Object.values(InternalFilterLookup);
-function isFilterLookup(value) {
-	return FILTER_LOOKUPS.includes(value);
-}
-/**
-* Declarative query-param to filter translation.
-*
-* A `FilterSet` lets viewsets expose safe, explicit filtering behavior
-* without leaking raw ORM filter syntax to request handlers.
-*/
-var FilterSet = class FilterSet {
-	spec;
-	allowAllParams;
-	static BRAND = "tango.resources.filter_set";
-	__tangoBrand = FilterSet.BRAND;
-	/**
-	* Resolve matching query parameters into ORM filter inputs.
-	*/
-	constructor(spec, allowAllParams = false) {
-		this.spec = spec;
-		this.allowAllParams = allowAllParams;
-	}
-	/**
-	* Build a filter set from Django-style field declarations.
-	*/
-	static define(config) {
-		return new FilterSet(FilterSet.normalizeDefineConfig(config), config.all === "__all__");
-	}
-	/**
-	* Narrow an unknown value to `FilterSet`.
-	*/
-	static isFilterSet(value) {
-		return typeof value === "object" && value !== null && value.__tangoBrand === FilterSet.BRAND;
-	}
-	static normalizeDefineConfig(config) {
-		const spec = {};
-		const fieldDeclarations = config.fields ?? {};
-		const fieldParsers = config.parsers ?? {};
-		for (const rawField of Object.keys(fieldDeclarations)) {
-			const declaration = fieldDeclarations[rawField];
-			if (declaration === void 0) continue;
-			const parser = fieldParsers[rawField];
-			FilterSet.addFieldDeclaration(spec, rawField, declaration, parser);
-		}
-		const aliases = config.aliases ?? {};
-		for (const [param, declaration] of Object.entries(aliases)) spec[param] = FilterSet.normalizeAliasDeclaration(declaration);
-		return spec;
-	}
-	static addFieldDeclaration(spec, field, declaration, parser) {
-		if (declaration === true) {
-			spec[String(field)] = FilterSet.createLookupResolver(field, InternalFilterLookup.EXACT, parser);
-			return;
-		}
-		if (FilterSet.isLookupArray(declaration)) {
-			for (const lookup of declaration) {
-				const param = FilterSet.resolveLookupParam(String(field), lookup);
-				spec[param] = FilterSet.createLookupResolver(field, lookup, parser);
-			}
-			return;
-		}
-		const lookups = declaration.lookups ?? [InternalFilterLookup.EXACT];
-		const baseParam = declaration.param ?? String(field);
-		const effectiveParser = declaration.parse ?? parser;
-		for (const lookup of lookups) {
-			const param = FilterSet.resolveLookupParam(baseParam, lookup);
-			spec[param] = FilterSet.createLookupResolver(field, lookup, effectiveParser);
-		}
-	}
-	static isLookupArray(value) {
-		return Array.isArray(value);
-	}
-	static normalizeAliasDeclaration(declaration) {
-		if (FilterSet.isFilterResolverDeclaration(declaration)) return declaration;
-		if ("fields" in declaration) {
-			const lookup = declaration.lookup ?? InternalFilterLookup.ICONTAINS;
-			return FilterSet.createMultiFieldResolver(declaration.fields, lookup, declaration.parse);
-		}
-		return FilterSet.createLookupResolver(declaration.field, declaration.lookup ?? InternalFilterLookup.EXACT, declaration.parse);
-	}
-	static isFilterResolverDeclaration(value) {
-		if (typeof value !== "object" || value === null || !("type" in value)) return false;
-		return [
-			InternalFilterType.SCALAR,
-			InternalFilterType.ILIKE,
-			InternalFilterType.RANGE,
-			InternalFilterType.IN,
-			InternalFilterType.CUSTOM
-		].includes(value.type);
-	}
-	static createMultiFieldResolver(fields, lookup, parser) {
-		if (lookup === InternalFilterLookup.ICONTAINS && parser === void 0) return {
-			type: InternalFilterType.ILIKE,
-			columns: [...fields]
-		};
-		return {
-			type: InternalFilterType.CUSTOM,
-			apply: (raw) => {
-				const parsed = FilterSet.resolveParserValue(raw, parser);
-				if (parsed === void 0) return void 0;
-				const composed = {};
-				for (const field of fields) {
-					const segment = FilterSet.resolveLookupFilter(field, lookup, parsed);
-					if (!segment) continue;
-					Object.assign(composed, segment);
-				}
-				return Object.keys(composed).length > 0 ? composed : void 0;
-			}
-		};
-	}
-	static createLookupResolver(field, lookup, parser) {
-		if (parser !== void 0) return {
-			type: InternalFilterType.CUSTOM,
-			apply: (raw) => {
-				const parsed = FilterSet.resolveParserValue(raw, parser);
-				if (parsed === void 0) return void 0;
-				return FilterSet.resolveLookupFilter(field, lookup, parsed);
-			}
-		};
-		switch (lookup) {
-			case "exact": return {
-				type: InternalFilterType.SCALAR,
-				column: field
-			};
-			case "in": return {
-				type: InternalFilterType.IN,
-				column: field
-			};
-			case "lt":
-			case "lte":
-			case "gt":
-			case "gte": return {
-				type: InternalFilterType.RANGE,
-				column: field,
-				op: lookup
-			};
-			case "icontains": return {
-				type: InternalFilterType.ILIKE,
-				columns: [field]
-			};
-			default: return {
-				type: InternalFilterType.CUSTOM,
-				apply: (raw) => FilterSet.resolveLookupFilter(field, lookup, raw)
-			};
-		}
-	}
-	static resolveLookupFilter(field, lookup, value) {
-		if (value === void 0) return void 0;
-		if (lookup === "exact") return { [field]: value };
-		if (lookup === "in") {
-			const arr = Array.isArray(value) ? value : String(value).split(",");
-			return { [`${String(field)}__in`]: arr };
-		}
-		if (lookup === "icontains") return { [`${String(field)}__icontains`]: `%${FilterSet.toScalarString(value)}%` };
-		return { [`${String(field)}__${lookup}`]: value };
-	}
-	static resolveLookupParam(baseParam, lookup) {
-		if (lookup === "exact") return baseParam;
-		return `${baseParam}__${lookup}`;
-	}
-	static resolveParserValue(value, parser) {
-		if (value === void 0) return;
-		if (parser === void 0) return value;
-		return parser(value);
-	}
-	static toScalarString(value) {
-		if (Array.isArray(value)) return value.join(",");
-		return String(value);
-	}
-	/**
-	* Return a new filter set with parser-aware scalar/range/in resolvers for matching fields.
-	*/
-	withFieldParsers(parsers) {
-		if (Object.keys(parsers).length === 0) return this;
-		let changed = false;
-		const nextSpec = Object.fromEntries(Object.entries(this.spec).map(([param, resolver]) => {
-			const nextResolver = this.applyFieldParserOverride(resolver, parsers);
-			if (nextResolver !== resolver) changed = true;
-			return [param, nextResolver];
-		}));
-		return changed ? new FilterSet(nextSpec, this.allowAllParams) : this;
-	}
-	/**
-	* Apply all configured resolvers against query params.
-	*/
-	apply(params) {
-		const filters = [];
-		const keys = /* @__PURE__ */ new Set();
-		for (const [key] of params.entries()) keys.add(key);
-		for (const key of keys) {
-			const resolver = this.spec[key] ?? (this.allowAllParams ? this.buildAllResolver(key) : void 0);
-			if (!resolver) continue;
-			const rawValue = params.getAll(key);
-			const value = rawValue.length > 1 ? rawValue : rawValue[0];
-			if (value === void 0) continue;
-			const filter = this.resolveFilter(resolver, value);
-			if (filter) filters.push(filter);
-		}
-		return filters;
-	}
-	buildAllResolver(param) {
-		const segments = param.split("__").filter(Boolean);
-		if (segments.length === 0) return;
-		const lastSegment = segments.at(-1);
-		const lookup = isFilterLookup(lastSegment) ? lastSegment : "exact";
-		const field = (lookup === "exact" ? segments : segments.slice(0, -1)).join("__");
-		if (!field) return;
-		if (lookup === "exact") return {
-			type: InternalFilterType.SCALAR,
-			column: field
-		};
-		return FilterSet.createLookupResolver(field, lookup);
-	}
-	resolveFilter(resolver, value) {
-		if (value === void 0) return void 0;
-		switch (resolver.type) {
-			case InternalFilterType.SCALAR: return { [resolver.column]: value };
-			case InternalFilterType.ILIKE: {
-				const pattern = `%${FilterSet.toScalarString(value)}%`;
-				const filter = {};
-				resolver.columns.forEach((col) => {
-					filter[`${String(col)}__icontains`] = pattern;
-				});
-				return filter;
-			}
-			case InternalFilterType.RANGE: return { [`${String(resolver.column)}__${resolver.op}`]: value };
-			case InternalFilterType.IN: {
-				const arr = Array.isArray(value) ? value : String(value).split(",");
-				return { [`${String(resolver.column)}__in`]: arr };
-			}
-			case InternalFilterType.CUSTOM: return resolver.apply(value);
-			default: return;
-		}
-	}
-	applyFieldParserOverride(resolver, parsers) {
-		switch (resolver.type) {
-			case InternalFilterType.SCALAR: {
-				const parser = parsers[resolver.column];
-				return parser ? FilterSet.createLookupResolver(resolver.column, "exact", parser) : resolver;
-			}
-			case InternalFilterType.RANGE: {
-				const parser = parsers[resolver.column];
-				return parser ? FilterSet.createLookupResolver(resolver.column, resolver.op, parser) : resolver;
-			}
-			case InternalFilterType.IN: {
-				const parser = parsers[resolver.column];
-				return parser ? FilterSet.createLookupResolver(resolver.column, "in", parser) : resolver;
-			}
-			default: return resolver;
-		}
-	}
-};
-//#endregion
-//#region src/filters/index.ts
-var filters_exports = /* @__PURE__ */ __exportAll({ FilterSet: () => FilterSet });
-//#endregion
-//#region src/pagination/CursorPaginationInput.ts
-const CursorPaginationInput = z.object({
-	limit: z.preprocess((value) => {
-		if (value === void 0 || value === null || value === "") return;
-		const parsed = Number.parseInt(String(value), 10);
-		if (!Number.isFinite(parsed) || parsed <= 0) return;
-		return parsed;
-	}, z.number().int().min(1).transform((value) => Math.min(value, 100)).optional()),
-	cursor: z.string().nullable().default(null),
-	ordering: z.string().optional()
-});
-//#endregion
-//#region src/paginators/CursorPaginator.ts
-/**
-* Represents a single cursor page of results.
-* Cursor pages do not expose numeric page navigation like offset pagination.
-*/
-var CursorPage = class CursorPage {
-	results;
-	nextCursor;
-	previousCursor;
-	static BRAND = "tango.resources.cursor_page";
-	__tangoBrand = CursorPage.BRAND;
-	constructor(results, nextCursor, previousCursor) {
-		this.results = results;
-		this.nextCursor = nextCursor;
-		this.previousCursor = previousCursor;
-	}
-	static isCursorPage(value) {
-		return typeof value === "object" && value !== null && value.__tangoBrand === CursorPage.BRAND;
-	}
-	/** Whether a next cursor token exists. */
-	hasNext() {
-		return this.nextCursor !== null;
-	}
-	/** Whether a previous cursor token exists. */
-	hasPrevious() {
-		return this.previousCursor !== null;
-	}
-	nextPageNumber() {
-		return null;
-	}
-	previousPageNumber() {
-		return null;
-	}
-	startIndex() {
-		return 0;
-	}
-	endIndex() {
-		return this.results.length;
-	}
-};
-/**
-* Cursor-based paginator for stable forward navigation with opaque cursor tokens.
-* It supports `limit`, `cursor`, and `ordering` query params and returns DRF-style
-* paginated envelopes with cursor links.
-*/
-var CursorPaginator = class CursorPaginator extends BasePaginator {
-	queryset;
-	perPage;
-	cursorField;
-	static BRAND = "tango.resources.cursor_paginator";
-	__tangoBrand = CursorPaginator.BRAND;
-	limit;
-	cursor = null;
-	direction = "asc";
-	nextCursor = null;
-	previousCursor = null;
-	constructor(queryset, perPage = 25, cursorField = "id") {
-		super();
-		this.queryset = queryset;
-		this.perPage = perPage;
-		this.cursorField = cursorField;
-		this.limit = perPage;
-	}
-	/**
-	* Narrow an unknown value to `CursorPaginator`.
-	*/
-	static isCursorPaginator(value) {
-		return typeof value === "object" && value !== null && value.__tangoBrand === CursorPaginator.BRAND;
-	}
-	/**
-	* Parse cursor pagination parameters from Tango query params.
-	*/
-	parse(params) {
-		const parsed = CursorPaginationInput.parse({
-			limit: params.get("limit") ?? void 0,
-			cursor: params.get("cursor"),
-			ordering: params.get("ordering") ?? void 0
-		});
-		this.limit = parsed.limit ?? this.perPage;
-		this.cursor = parsed.cursor;
-		const ordering = parsed.ordering;
-		if (ordering) {
-			const parsedDirection = ordering.startsWith("-") ? "desc" : "asc";
-			const parsedField = ordering.startsWith("-") ? ordering.slice(1) : ordering;
-			this.direction = parsedField === String(this.cursorField) ? parsedDirection : "asc";
-		} else this.direction = "asc";
-	}
-	/**
-	* Parse params and return compatibility `{ limit, offset }` shape.
-	*/
-	parseParams(params) {
-		this.parse(params);
-		return {
-			limit: this.limit,
-			offset: 0
-		};
-	}
-	/**
-	* Build a paginated response payload with cursor links.
-	*/
-	needsTotalCount() {
-		return false;
-	}
-	toResponse(results, _context) {
-		const response = { results: this.resolveQueryResultRows(results) };
-		if (this.nextCursor) response.next = this.buildPageLink(this.nextCursor);
-		if (this.previousCursor) response.previous = this.buildPageLink(this.previousCursor);
-		return response;
-	}
-	/**
-	* Backward-compatible alias for `toResponse`.
-	*/
-	getPaginatedResponse(results, _totalCount) {
-		return this.toResponse(results);
-	}
-	/**
-	* Apply cursor constraints and ordering to a queryset.
-	*/
-	apply(queryset) {
-		let qs = queryset.limit(this.limit + 1);
-		if (this.cursor) {
-			const decoded = this.decodeCursor(this.cursor);
-			if (decoded.field !== String(this.cursorField)) throw new Error("Invalid cursor: field mismatch");
-			const lookup = this.direction === "asc" ? "__gt" : "__lt";
-			const filterInput = { [`${String(this.cursorField)}${lookup}`]: decoded.value };
-			qs = qs.filter(filterInput);
-		}
-		const orderToken = this.direction === "asc" ? String(this.cursorField) : `-${String(this.cursorField)}`;
-		return qs.orderBy(orderToken);
-	}
-	/**
-	* Fetch the next cursor page.
-	*/
-	async paginate(cursor) {
-		const appliedCursor = cursor ?? this.cursor;
-		this.cursor = appliedCursor;
-		const fetched = await this.apply(this.queryset).fetch();
-		const results = this.resolveQueryResultRows(fetched);
-		const hasMore = results.length > this.limit;
-		if (hasMore) results.pop();
-		this.previousCursor = appliedCursor ?? null;
-		const last = results.at(-1);
-		this.nextCursor = hasMore && last ? this.encodeCursor(last) : null;
-		return new CursorPage(results, this.nextCursor, this.previousCursor);
-	}
-	/**
-	* Cursor paginators only support page `1` as an entry point.
-	*/
-	async getPage(page) {
-		if (page !== 1) throw new Error("CursorPaginator only supports getPage(1). Use cursor pagination for subsequent pages.");
-		return this.paginate();
-	}
-	buildPageLink(cursor) {
-		const orderingToken = this.direction === "asc" ? String(this.cursorField) : `-${String(this.cursorField)}`;
-		return `?limit=${this.limit}&cursor=${encodeURIComponent(cursor)}&ordering=${encodeURIComponent(orderingToken)}`;
-	}
-	encodeCursor(item) {
-		const payload = {
-			v: 1,
-			field: String(this.cursorField),
-			dir: this.direction,
-			value: item[this.cursorField]
-		};
-		return Buffer.from(JSON.stringify(payload), "utf-8").toString("base64");
-	}
-	decodeCursor(cursor) {
-		let parsed;
-		try {
-			parsed = JSON.parse(Buffer.from(cursor, "base64").toString("utf-8"));
-		} catch {
-			throw new Error("Invalid cursor: malformed token");
-		}
-		if (!parsed || typeof parsed !== "object" || parsed.v !== 1 || typeof parsed.field !== "string" || parsed.dir !== "asc" && parsed.dir !== "desc" || !("value" in parsed)) throw new Error("Invalid cursor: unsupported payload");
-		return parsed;
-	}
-};
-//#endregion
-//#region src/pagination/index.ts
-var pagination_exports = /* @__PURE__ */ __exportAll({
-	BasePaginator: () => BasePaginator,
-	CursorPaginationInput: () => CursorPaginationInput,
-	CursorPaginator: () => CursorPaginator,
-	OffsetPaginationInput: () => OffsetPaginationInput,
-	OffsetPaginator: () => OffsetPaginator
-});
-//#endregion
-//#region src/paginators/index.ts
-var paginators_exports = /* @__PURE__ */ __exportAll({
-	CursorPaginator: () => CursorPaginator,
-	OffsetPaginator: () => OffsetPaginator
-});
-//#endregion
-//#region src/resource/index.ts
-var resource_exports = /* @__PURE__ */ __exportAll({});
-//#endregion
-//#region src/serializer/Serializer.ts
-const logger = getLogger("tango.resources.serializer");
-let hasWarnedAboutToRepresentationDeprecation = false;
-/**
-* DRF-inspired base serializer backed by Zod schemas.
-*
-* Tango serializers keep Zod as the source of truth for validation and type
-* inference while centralizing create, update, and representation workflows in
-* one class-owned contract.
-*/
-var Serializer = class {
-	static createSchema = z.unknown();
-	static updateSchema = z.unknown();
-	static outputSchema = z.unknown();
-	static outputResolvers = void 0;
-	/**
-	* Return the serializer class for the current instance.
-	*/
-	getSerializerClass() {
-		return this.constructor;
-	}
-	/**
-	* Return the Zod schema used for create payloads.
-	*/
-	getCreateSchema() {
-		return this.getSerializerClass().createSchema;
-	}
-	/**
-	* Return the Zod schema used for update payloads.
-	*/
-	getUpdateSchema() {
-		return this.getSerializerClass().updateSchema;
-	}
-	/**
-	* Return the Zod schema used for serialized output.
-	*/
-	getOutputSchema() {
-		return this.getSerializerClass().outputSchema;
-	}
-	/**
-	* Return the resolver map used to enrich serializer output fields before
-	* the outward Zod schema parses the final response shape.
-	*/
-	getOutputResolvers() {
-		return this.getSerializerClass().outputResolvers ?? {};
-	}
-	/**
-	* Validate unknown input for create workflows.
-	*/
-	deserializeCreate(input) {
-		return this.getCreateSchema().parse(input);
-	}
-	/**
-	* Validate unknown input for update workflows.
-	*/
-	deserializeUpdate(input) {
-		return this.getUpdateSchema().parse(input);
-	}
-	/**
-	* Convert a persisted record into its outward-facing representation.
-	*
-	* @deprecated Use `serialize(...)` instead so serializer-owned output
-	* resolvers run before the outward Zod schema parses the response shape.
-	*/
-	toRepresentation(record) {
-		if (!hasWarnedAboutToRepresentationDeprecation) {
-			hasWarnedAboutToRepresentationDeprecation = true;
-			logger.warn("`Serializer.toRepresentation(...)` is deprecated. Use `serialize(...)` instead so output resolvers run before outward parsing.");
-		}
-		return this.getOutputSchema().parse(record);
-	}
-	/**
-	* Resolve serializer-owned output fields and parse the outward response
-	* contract.
-	*/
-	async serialize(record) {
-		return this.getOutputSchema().parse(await this.applyOutputResolvers(record));
-	}
-	/**
-	* Serialize many records through the same outward response contract.
-	*/
-	async serializeMany(records) {
-		return Promise.all(records.map((record) => this.serialize(record)));
-	}
-	async applyOutputResolvers(record) {
-		const resolvers = this.getOutputResolvers();
-		const resolverEntries = Object.entries(resolvers);
-		if (resolverEntries.length === 0 || typeof record !== "object" || record === null) return record;
-		const resolved = await Promise.all(resolverEntries.map(async ([key, resolver]) => [key, await resolver(record)]));
-		return {
-			...record,
-			...Object.fromEntries(resolved)
-		};
-	}
-};
-//#endregion
-//#region src/serializer/internal/InternalSerializerRelationKind.ts
-const InternalSerializerRelationKind = { MANY_TO_MANY: "manyToMany" };
-const InternalManyToManyReadStrategyKind = {
-	PK_LIST: "pkList",
-	NESTED: "nested"
-};
-const InternalManyToManyWriteStrategyKind = {
-	PK_LIST: "pkList",
-	SLUG_LIST: "slugList"
-};
-//#endregion
-//#region src/serializer/ModelSerializer.ts
-/**
-* Zod-backed serializer with default model-manager persistence behavior.
-*/
-var ModelSerializer = class extends Serializer {
-	static model;
-	static relationFields = void 0;
-	/**
-	* Return the Tango model backing this serializer.
-	*/
-	getModel() {
-		const model = this.constructor.model;
-		if (!model) throw new Error(`${this.constructor.name} must define a static model or override getModel().`);
-		return model;
-	}
-	/**
-	* Return the manager used for create and update workflows.
-	*/
-	getManager() {
-		return this.getModel().objects;
-	}
-	/**
-	* Return the declarative relation-field map for this serializer.
-	*/
-	getRelationFields() {
-		return this.constructor.relationFields ?? {};
-	}
-	/**
-	* Merge relation-field read resolvers into the serializer output path.
-	*/
-	getOutputResolvers() {
-		const baseResolvers = super.getOutputResolvers();
-		const relationFields = this.getRelationFields();
-		return {
-			...Object.fromEntries(Object.entries(relationFields).map(([fieldName, field]) => [fieldName, async (record) => this.serializeRelationField(record, fieldName, field)])),
-			...baseResolvers
-		};
-	}
-	/**
-	* Validate, enrich, persist, and serialize a create workflow.
-	*/
-	async create(input) {
-		const validated = this.deserializeCreate(input);
-		const relationWrites = this.extractRelationWrites(validated, input);
-		const prepared = await this.beforeCreate(validated);
-		const created = await this.getManager().create(this.stripRelationFields(prepared));
-		await this.applyRelationWrites(created, relationWrites);
-		return this.serialize(created);
-	}
-	/**
-	* Validate, enrich, persist, and serialize an update workflow.
-	*/
-	async update(id, input) {
-		const validated = this.deserializeUpdate(input);
-		const relationWrites = this.extractRelationWrites(validated, input);
-		const prepared = await this.beforeUpdate(id, validated);
-		const updated = await this.getManager().update(id, this.stripRelationFields(prepared));
-		await this.applyRelationWrites(updated, relationWrites);
-		return this.serialize(updated);
-	}
-	/**
-	* Override to normalize create input for this resource workflow before the
-	* manager call.
-	*
-	* Model-owned persistence rules belong in model hooks so they also run for
-	* scripts and direct manager usage.
-	*/
-	async beforeCreate(data) {
-		return data;
-	}
-	/**
-	* Override to normalize update input for this resource workflow before the
-	* manager call.
-	*
-	* Model-owned persistence rules belong in model hooks so they also run for
-	* scripts and direct manager usage.
-	*/
-	async beforeUpdate(_id, data) {
-		return data;
-	}
-	extractRelationWrites(data, rawInput) {
-		if (typeof data !== "object" || data === null || typeof rawInput !== "object" || rawInput === null) return {};
-		const relationFields = this.getRelationFields();
-		const writes = {};
-		for (const fieldName of Object.keys(relationFields)) if (fieldName in rawInput) writes[fieldName] = data[fieldName];
-		return writes;
-	}
-	stripRelationFields(data) {
-		const relationFieldNames = new Set(Object.keys(this.getRelationFields()));
-		if (relationFieldNames.size === 0) return data;
-		return Object.fromEntries(Object.entries(data).filter(([fieldName]) => !relationFieldNames.has(fieldName)));
-	}
-	async applyRelationWrites(record, writes) {
-		const relationFields = this.getRelationFields();
-		for (const [fieldName, value] of Object.entries(writes)) {
-			if (!relationFields[fieldName]) continue;
-			await this.syncManyToManyRelation(record, fieldName, value);
-		}
-	}
-	async serializeRelationField(record, fieldName, field) {
-		const rows = (await this.getManyToManyManager(record, fieldName).all().fetch()).results;
-		const relationMeta = this.getManyToManyRelationMeta(fieldName);
-		switch (field.read.kind) {
-			case InternalManyToManyReadStrategyKind.PK_LIST: return rows.map((row) => row[relationMeta.targetPrimaryKey]);
-			case InternalManyToManyReadStrategyKind.NESTED: return rows.map((row) => field.read.schema.parse(row));
-		}
-	}
-	async syncManyToManyRelation(record, fieldName, value) {
-		if (value === void 0) return;
-		const manager = this.getManyToManyManager(record, fieldName);
-		const field = this.getRelationFields()[fieldName];
-		if (!field) return;
-		const nextTargets = await this.resolveWriteTargets(fieldName, field.write, value);
-		await manager.set(...nextTargets);
-	}
-	async resolveWriteTargets(fieldName, strategy, value) {
-		switch (strategy.kind) {
-			case InternalManyToManyWriteStrategyKind.PK_LIST:
-				if (!Array.isArray(value)) throw new TypeError(`Relation field '${String(fieldName)}' expects an array of primary-key values.`);
-				return value;
-			case InternalManyToManyWriteStrategyKind.SLUG_LIST: {
-				if (!Array.isArray(value)) throw new TypeError(`Relation field '${String(fieldName)}' expects an array of lookup values.`);
-				const lookupValues = [...new Set(value.map((entry) => String(entry).trim()).filter(Boolean))];
-				if (lookupValues.length === 0) return [];
-				const filter = { [`${strategy.lookupField}__in`]: lookupValues };
-				const existing = await strategy.model.objects.query().filter(filter).fetch();
-				const byLookup = new Map(existing.results.map((row) => [String(row[strategy.lookupField]), row]));
-				const resolved = [];
-				for (const lookupValue of lookupValues) {
-					const found = byLookup.get(lookupValue);
-					if (found) {
-						resolved.push(found);
-						continue;
-					}
-					if (!strategy.createIfMissing) throw new Error(`Relation field '${String(fieldName)}' could not resolve '${lookupValue}' via '${strategy.lookupField}'.`);
-					const created = await strategy.model.objects.create(strategy.buildCreateInput?.(lookupValue) ?? { [strategy.lookupField]: lookupValue });
-					resolved.push(created);
-				}
-				return resolved;
-			}
-		}
-	}
-	getManyToManyManager(record, fieldName) {
-		const manager = record[fieldName];
-		if (!ManyToManyRelatedManager.isManyToManyRelatedManager(manager)) throw new Error(`Relation field '${fieldName}' is not backed by a many-to-many related manager.`);
-		return manager;
-	}
-	getManyToManyRelationMeta(fieldName) {
-		const relation = this.getManager().meta.relations?.[fieldName];
-		if (!relation || relation.kind !== InternalSerializerRelationKind.MANY_TO_MANY) throw new Error(`Relation field '${fieldName}' is not a persisted many-to-many edge.`);
-		return relation;
-	}
-};
-//#endregion
-//#region src/serializer/relation.ts
-function pkList() {
-	return { kind: InternalManyToManyReadStrategyKind.PK_LIST };
-}
-function nested(schema) {
-	return {
-		kind: InternalManyToManyReadStrategyKind.NESTED,
-		schema
-	};
-}
-function slugList(options) {
-	return {
-		kind: InternalManyToManyWriteStrategyKind.SLUG_LIST,
-		...options
-	};
-}
-function manyToMany(config = {}) {
-	return {
-		kind: InternalSerializerRelationKind.MANY_TO_MANY,
-		read: config.read ?? pkList(),
-		write: config.write ?? pkList()
-	};
-}
-const relation = {
-	manyToMany,
-	pkList,
-	nested,
-	slugList
-};
-//#endregion
-//#region src/serializer/index.ts
-var serializer_exports = /* @__PURE__ */ __exportAll({
-	ModelSerializer: () => ModelSerializer,
-	Serializer: () => Serializer,
-	relation: () => relation
-});
-//#endregion
-//#region src/viewset/ModelViewSet.ts
-/**
-* Base class for creating RESTful API viewsets with built-in CRUD operations.
-* Provides list, retrieve, create, update, and delete methods with filtering,
-* search, pagination, and ordering support.
-*/
-var ModelViewSet = class ModelViewSet {
-	static BRAND = "tango.resources.model_view_set";
-	static actions = [];
-	__tangoBrand = ModelViewSet.BRAND;
-	serializerClass;
-	filters;
-	orderingFields;
-	searchFields;
-	paginatorFactory;
-	serializer;
-	constructor(config) {
-		this.serializerClass = config.serializer;
-		this.filters = config.filters;
-		this.orderingFields = config.orderingFields ?? [];
-		this.searchFields = config.searchFields ?? [];
-		this.paginatorFactory = config.paginatorFactory;
-	}
-	/**
-	* Return the custom action descriptors declared by a viewset or constructor.
-	*/
-	static getActions(viewsetOrConstructor) {
-		const viewset = ModelViewSet.isModelViewSet(viewsetOrConstructor) ? viewsetOrConstructor : null;
-		const constructorValue = viewset ? viewset.constructor : viewsetOrConstructor;
-		return (Array.isArray(constructorValue.actions) ? constructorValue.actions : []).map((action) => ({
-			...action,
-			path: viewset ? viewset.resolveActionPath(action) : ModelViewSet.resolvePathFromDescriptor(action.name, action.path)
-		}));
-	}
-	/**
-	* Narrow an unknown value to `ModelViewSet`.
-	*/
-	static isModelViewSet(value) {
-		return typeof value === "object" && value !== null && value.__tangoBrand === ModelViewSet.BRAND;
-	}
-	/**
-	* Preserve literal action inference while validating the descriptor shape.
-	*/
-	static defineViewSetActions(actions) {
-		return actions;
-	}
-	static resolvePathFromDescriptor(name, explicitPath) {
-		const normalized = (explicitPath?.trim() || ModelViewSet.toKebabCase(name)).replace(/^\/+|\/+$/g, "");
-		if (!normalized) throw new Error(`Invalid custom action path for '${name}'.`);
-		return normalized;
-	}
-	static toKebabCase(input) {
-		return input.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/[_\s]+/g, "-").toLowerCase();
-	}
-	/**
-	* Return the serializer class that owns this resource contract.
-	*/
-	getSerializerClass() {
-		return this.serializerClass;
-	}
-	/**
-	* Return the serializer instance for the current resource.
-	*/
-	getSerializer() {
-		if (!this.serializer) this.serializer = new this.serializerClass();
-		return this.serializer;
-	}
-	/**
-	* Describe the public HTTP contract that this resource contributes to OpenAPI generation.
-	*/
-	describeOpenAPI() {
-		const model = this.requireModelMetadata();
-		return {
-			model,
-			outputSchema: this.getSerializer().getOutputSchema(),
-			createSchema: this.getSerializer().getCreateSchema(),
-			updateSchema: this.getSerializer().getUpdateSchema(),
-			searchFields: this.searchFields,
-			orderingFields: this.orderingFields,
-			lookupField: this.getLookupFieldFromMetadata(model),
-			lookupParam: "id",
-			allowedMethods: [
-				"GET",
-				"POST",
-				"PUT",
-				"PATCH",
-				"DELETE"
-			],
-			usesDefaultOffsetPagination: !this.paginatorFactory,
-			actions: ModelViewSet.getActions(this)
-		};
-	}
-	/**
-	* List endpoint with filtering, search, ordering, and offset pagination.
-	*/
-	async list(ctx) {
-		try {
-			const params = ctx.request.queryParams;
-			const baseQueryset = this.getManager().query();
-			const paginator = this.getPaginator(baseQueryset);
-			paginator.parse(params);
-			let qs = baseQueryset;
-			if (this.filters) {
-				const filterInputs = this.filters.withFieldParsers(inferModelFieldParsers(this.getSerializer().getModel())).apply(params);
-				if (filterInputs.length > 0) qs = qs.filter(Q.and(...filterInputs));
-			}
-			const search = params.getSearch();
-			if (search && this.searchFields.length > 0) {
-				const searchFilters = this.searchFields.map((field) => {
-					return { [`${String(field)}__icontains`]: search };
-				});
-				qs = qs.filter(Q.or(...searchFilters));
-			}
-			const ordering = params.getOrdering();
-			if (ordering.length > 0) {
-				const orderTokens = ordering.filter((field) => {
-					const cleanField = field.startsWith("-") ? field.slice(1) : field;
-					return this.orderingFields.includes(cleanField);
-				});
-				if (orderTokens.length > 0) qs = qs.orderBy(...orderTokens.map((token) => token));
-			}
-			const resultPromise = paginator.apply(qs).fetch();
-			const totalCountPromise = paginator.needsTotalCount() ? qs.count() : Promise.resolve(void 0);
-			const [result, totalCount] = await Promise.all([resultPromise, totalCountPromise]);
-			const rows = await this.getSerializer().serializeMany(result.items);
-			const response = paginator.toResponse(rows, { totalCount });
-			return TangoResponse.json(response, { status: 200 });
-		} catch (error) {
-			return this.handleError(error);
-		}
-	}
-	/**
-	* Retrieve endpoint for a single resource by id.
-	*/
-	async retrieve(_ctx, id) {
-		try {
-			const manager = this.getManager();
-			const pk = manager.meta.pk;
-			const filterById = { [pk]: id };
-			const result = await manager.query().filter(filterById).fetchOne();
-			if (!result) throw new NotFoundError(`No ${manager.meta.table} record found for ${String(pk)}=${id}.`);
-			return TangoResponse.json(await this.getSerializer().serialize(result), { status: 200 });
-		} catch (error) {
-			return this.handleError(error);
-		}
-	}
-	/**
-	* Create endpoint: validate input, persist, and return serialized output.
-	*/
-	async create(ctx) {
-		try {
-			const body = await ctx.request.json();
-			const result = await this.getSerializer().create(body);
-			return TangoResponse.created(void 0, result);
-		} catch (error) {
-			return this.handleError(error);
-		}
-	}
-	/**
-	* Update endpoint: validate partial payload and persist by id.
-	*/
-	async update(ctx, id) {
-		try {
-			const body = await ctx.request.json();
-			const pkValue = id;
-			const result = await this.getSerializer().update(pkValue, body);
-			return TangoResponse.json(result, { status: 200 });
-		} catch (error) {
-			return this.handleError(error);
-		}
-	}
-	/**
-	* Destroy endpoint: delete a resource by id.
-	*/
-	async destroy(_ctx, id) {
-		try {
-			const pkValue = id;
-			await this.getManager().delete(pkValue);
-			return TangoResponse.noContent();
-		} catch (error) {
-			return this.handleError(error);
-		}
-	}
-	getPaginator(queryset) {
-		if (this.paginatorFactory) return this.paginatorFactory(queryset);
-		return new OffsetPaginator(queryset);
-	}
-	getManager() {
-		return this.getSerializer().getManager();
-	}
-	/**
-	* Convert thrown errors into normalized HTTP responses.
-	*/
-	handleError(error) {
-		const httpError = HttpErrorFactory.toHttpError(error);
-		return TangoResponse.json(httpError.body, { status: httpError.status });
-	}
-	/**
-	* Resolve route path segment(s) for a custom action.
-	* Override this in subclasses to customize path derivation globally.
-	*/
-	resolveActionPath(action) {
-		return ModelViewSet.resolvePathFromDescriptor(action.name, action.path);
-	}
-	requireModelMetadata() {
-		const model = this.getSerializer().getModel();
-		if (!model.metadata) throw new Error("OpenAPI generation requires Tango model metadata on ModelViewSet models.");
-		return model;
-	}
-	getLookupFieldFromMetadata(model) {
-		const primaryKeyField = model.metadata.fields.find((field) => field.primaryKey);
-		if (!primaryKeyField) throw new Error("OpenAPI generation requires a primary key field in Tango model metadata.");
-		return primaryKeyField.name;
-	}
-};
-//#endregion
-//#region src/viewset/index.ts
-var viewset_exports = /* @__PURE__ */ __exportAll({ ModelViewSet: () => ModelViewSet });
-//#endregion
+import { n as RequestContext, t as context_exports } from "./context-euBQvNRT.js";
+import { n as FilterSet, t as filters_exports } from "./filters-46d2Nr5C.js";
+import { n as OffsetPaginationInput, t as OffsetPaginator } from "./OffsetPaginator-CaycvxJU.js";
+import { n as CursorPaginationInput, t as CursorPaginator } from "./CursorPaginator-B_8MhYZY.js";
+import { t as pagination_exports } from "./pagination/index.js";
+import { t as paginators_exports } from "./paginators/index.js";
+import { t as resource_exports } from "./resource/index.js";
+import { i as Serializer, n as relation, r as ModelSerializer, t as serializer_exports } from "./serializer-RSwlXWls.js";
+import { n as ModelViewSet, t as viewset_exports } from "./viewset-C9j-2U29.js";
+import { a as ListCreateAPIView, c as ListAPIView, d as RetrieveModelMixin, f as CreateModelMixin, h as APIView, i as RetrieveUpdateAPIView, l as DestroyModelMixin, m as GenericAPIView, n as RetrieveUpdateDestroyAPIView, o as RetrieveAPIView, p as ListModelMixin, r as RetrieveDestroyAPIView, s as CreateAPIView, t as view_exports, u as UpdateModelMixin } from "./view-CYdJAO4t.js";
 export { APIView, CreateAPIView, CreateModelMixin, CursorPaginationInput, CursorPaginator, DestroyModelMixin, FilterSet, GenericAPIView, ListAPIView, ListCreateAPIView, ListModelMixin, ModelSerializer, ModelViewSet, OffsetPaginationInput, OffsetPaginator, RequestContext, RetrieveAPIView, RetrieveDestroyAPIView, RetrieveModelMixin, RetrieveUpdateAPIView, RetrieveUpdateDestroyAPIView, Serializer, UpdateModelMixin, context_exports as context, filters_exports as filters, pagination_exports as pagination, paginators_exports as paginators, relation, resource_exports as resource, serializer_exports as serializer, view_exports as view, viewset_exports as viewset };
-
-//# sourceMappingURL=index.js.map