bazis 0.98.1 → 0.98.3

package/cli/templates/module.ts

@@ -355,7 +355,7 @@ function listQueryFile(n: ModuleNaming): string {
   return `import { Filterable, ListOptions, ListRequest, Sortable } from "bazis/core/http";
 import type { ${n.entity} } from "../../model/${n.module}.model";
 
-@ListOptions({ defaultSize: 20, maxSize: 100 })
+@ListOptions({ defaultSize: 20, maxSize: 100, defaultSort: "-createdAt" })
 export class ${n.module}ListQuery extends ListRequest<${n.entity}> {
   @Sortable()
   @Filterable("eq", "contains", "startsWith")

package/core/http/Binding/ParameterBinder.ts

@@ -11,6 +11,20 @@ export interface BindingDefaults {
   consumes?: string;
 }
 
+const BODILESS_METHODS = new Set(["GET", "HEAD", "OPTIONS"]);
+
+/**
+ * `consumes` of a route applies to every request with a body, however the
+ * action reads it: a body model, `ctx.formData()`, `ctx.text()` or nothing.
+ */
+export function assertConsumes(ctx: HttpContext, consumes: string | undefined): void {
+  if (consumes === undefined || BODILESS_METHODS.has(ctx.method)) return;
+  const contentType = ctx.header("content-type") ?? "";
+  if (!contentType.toLowerCase().startsWith(consumes.toLowerCase())) {
+    throw new UnsupportedMediaTypeError(consumes);
+  }
+}
+
 function bindValue(binding: ParameterBinding, raw: string | undefined, kind: string): unknown {
   if (raw === undefined) {
     if (binding.defaultValue !== undefined) {

package/core/http/Routing/RouterBuilder.ts

@@ -1,5 +1,5 @@
 import type { Class, Token } from "../../di";
-import { bindArguments } from "../Binding/ParameterBinder";
+import { assertConsumes, bindArguments } from "../Binding/ParameterBinder";
 import { resolveGeneratedBindings } from "../Binding/autoBindings";
 import { generatedSourcesAreStale } from "../../generatedFingerprint";
 import { controllerMetaOf, type ActionMeta, type ControllerMeta } from "../Decorators/metadata";
@@ -139,6 +139,7 @@ export class RouterBuilder {
 
     const boundary: HttpMiddleware = async (ctx, next) => {
       try {
+        assertConsumes(ctx, bindingDefaults.consumes);
         const args = bindings ? await bindArguments(bindings, ctx, bindingDefaults) : [ctx];
         for (const filter of filters) {
           await filter.before?.(ctx);

package/core/infra/connectors/codex/CodexAppServerClient.ts

@@ -232,7 +232,7 @@ export class CodexAppServerClient implements CodexClient {
         if (method === "account/updated") this.modelCache = undefined;
       }, () => { this.clearLogin(); this.modelCache = undefined; });
       const initialized = await client.request("initialize", {
-        clientInfo: { name: "bazis", title: "Bazis", version: "0.98.1" }, capabilities: { experimentalApi: true },
+        clientInfo: { name: "bazis", title: "Bazis", version: "0.98.3" }, capabilities: { experimentalApi: true },
       }, 15_000, signal);
       if (resolve(text(initialized.codexHome, 4096)) !== this.paths.home) throw new CodexError("PROTOCOL_ERROR");
       client.notify("initialized");

package/library/jsonapi/decorators.ts

@@ -18,6 +18,7 @@ export interface ListSchema {
   readonly fields: Record<string, FieldSchema>;
   page?: PageOptions;
   include?: readonly string[];
+  defaultSort?: string;
 }
 
 interface SchemaMetadata {
@@ -32,6 +33,11 @@ export interface ListOptionsConfig {
   readonly maxSize?: number;
   /** Allowed include paths (`?include=`). */
   readonly include?: readonly string[];
+  /**
+   * Sorting when the request has no `sort`: `"-createdAt"`, `"-createdAt,name"`.
+   * Every field must be `@Sortable()`. The primary key still breaks ties.
+   */
+  readonly defaultSort?: string;
 }
 
 /**
@@ -43,7 +49,7 @@ function ensureOwnSchema(metadata: SchemaMetadata): ListSchema {
   if (!Object.prototype.hasOwnProperty.call(metadata, LIST_SCHEMA)) {
     const inherited = metadata[LIST_SCHEMA];
     metadata[LIST_SCHEMA] = inherited
-      ? { fields: cloneFields(inherited.fields), page: inherited.page, include: inherited.include }
+      ? { fields: cloneFields(inherited.fields), page: inherited.page, include: inherited.include, defaultSort: inherited.defaultSort }
       : { fields: {} };
   }
   return metadata[LIST_SCHEMA]!;
@@ -124,6 +130,16 @@ export function ListOptions(config: ListOptionsConfig) {
     if (config.include !== undefined) {
       schema.include = config.include;
     }
+    if (config.defaultSort !== undefined) {
+      // Field decorators have already run: check the declared fields now, at import time.
+      for (const token of config.defaultSort.split(",").map((part) => part.trim()).filter(Boolean)) {
+        const field = token.replace(/^[-+]/, "");
+        if (schema.fields[field]?.sortable !== true) {
+          throw new Error(`@ListOptions on ${String(context.name)}: defaultSort field "${field}" is not @Sortable().`);
+        }
+      }
+      schema.defaultSort = config.defaultSort;
+    }
   };
 }
 
@@ -157,5 +173,5 @@ export function optionsFromSchema(ctor: unknown): ListQueryOptions {
       filter[name] = field.filterOps;
     }
   }
-  return { sort, filter, include: schema.include, page: schema.page };
+  return { sort, filter, include: schema.include, page: schema.page, defaultSort: schema.defaultSort };
 }

package/library/jsonapi/document.ts

@@ -38,6 +38,12 @@ export interface BuildListDocumentOptions {
    * `links` are not built.
    */
   readonly basePath?: string;
+  /**
+   * JSON:API resource type for sparse fieldsets: `?fields[tasks]=name` keeps
+   * only `id` and `name` in every item. Default: the last segment of
+   * `basePath` (`"/api/tasks"` → `"tasks"`).
+   */
+  readonly type?: string;
 }
 
 /**
@@ -59,10 +65,29 @@ export function buildListDocument<T>(
   const pageCount = size > 0 ? Math.max(1, Math.ceil(total / size)) : 1;
   const meta: ListMeta = { total, page: query.page.number, size, pageCount };
 
+  const data = sparseFieldset(items, query, options.type ?? lastSegment(options.basePath));
   if (options.basePath === undefined) {
-    return { data: items, meta };
+    return { data, meta };
+  }
+  return { data, meta, links: buildLinks(query, options.basePath, meta) };
+}
+
+/** Items reduced to `id` and the fields requested with `fields[type]`; unchanged without it. */
+function sparseFieldset<T>(items: readonly T[], query: ListQuery, type: string | undefined): readonly T[] {
+  const fields = type === undefined ? undefined : query.fields[type];
+  if (fields === undefined || fields.length === 0) {
+    return items;
   }
-  return { data: items, meta, links: buildLinks(query, options.basePath, meta) };
+  const keep = new Set(["id", ...fields]);
+  return items.map((item) => {
+    if (item === null || typeof item !== "object") return item;
+    return Object.fromEntries(Object.entries(item as Record<string, unknown>).filter(([key]) => keep.has(key))) as T;
+  });
+}
+
+function lastSegment(basePath: string | undefined): string | undefined {
+  const segment = basePath?.split("?")[0]?.split("/").filter(Boolean).at(-1);
+  return segment === undefined || segment === "" ? undefined : segment;
 }
 
 /**

package/library/jsonapi/parseListQuery.ts

@@ -77,7 +77,9 @@ function parseSort(
   problems: ListQueryProblem[],
 ): SortField[] {
   const result: SortField[] = [];
-  for (const token of splitCsv(params.getAll("sort"))) {
+  const requested = splitCsv(params.getAll("sort"));
+  const tokens = requested.length === 0 && options.defaultSort !== undefined ? splitCsv([options.defaultSort]) : requested;
+  for (const token of tokens) {
     const dir: SortDirection = token.startsWith("-") ? "desc" : "asc";
     const field = token.replace(/^[-+]/, "");
     if (field === "") {

package/library/jsonapi/types.ts

@@ -122,4 +122,6 @@ export interface ListQueryOptions {
   readonly include?: readonly string[];
   /** Paging limits. */
   readonly page?: PageOptions;
+  /** Sorting when the request has no `sort`, in the same syntax: `"-createdAt,name"`. */
+  readonly defaultSort?: string;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bazis",
-  "version": "0.98.1",
+  "version": "0.98.3",
   "description": "Modular backend framework for Bun in TypeScript: DI wired by codegen, HTTP, a PostgreSQL ORM, JWT, WebSocket, agents and a CLI.",
   "license": "MIT",
   "author": "Alexander Alenin",