@primate/core 0.9.4 → 0.9.6

package/lib/private/db/errors.d.ts

@@ -34,6 +34,7 @@ declare function sort_invalid_value(field: string, value: unknown): import("@rco
 declare function select_empty(): import("@rcompat/error").TemplateError;
 declare function select_invalid(): import("@rcompat/error").TemplateError;
 declare function limit_invalid(): import("@rcompat/error").TemplateError;
+declare function first_limit_invalid(): import("@rcompat/error").TemplateError;
 declare function select_invalid_value(index: number, x: unknown): import("@rcompat/error").TemplateError;
 declare function where_required(): import("@rcompat/error").TemplateError;
 declare function where_invalid(): import("@rcompat/error").TemplateError;
@@ -94,6 +95,7 @@ declare const errors: {
     where_invalid_value: typeof where_invalid_value;
     set_empty: typeof set_empty;
     limit_invalid: typeof limit_invalid;
+    first_limit_invalid: typeof first_limit_invalid;
     offset_invalid: typeof offset_invalid;
     offset_requires_limit: typeof offset_requires_limit;
     relation_unknown: typeof relation_unknown;
@@ -150,6 +152,7 @@ export declare const Code: {
     where_invalid_value: "where_invalid_value";
     set_empty: "set_empty";
     limit_invalid: "limit_invalid";
+    first_limit_invalid: "first_limit_invalid";
     offset_invalid: "offset_invalid";
     offset_requires_limit: "offset_requires_limit";
     relation_unknown: "relation_unknown";

package/lib/private/db/errors.js

@@ -152,6 +152,9 @@ function select_invalid() {
 function limit_invalid() {
     return t `invalid limit`;
 }
+function first_limit_invalid() {
+    return t `${"first"} does not accept ${"limit"}`;
+}
 function select_invalid_value(index, x) {
     return t `select[${index}]: must be string, received ${kind_of(x)}`;
 }
@@ -185,6 +188,7 @@ const QUERY = error.coded({
     where_invalid_value,
     set_empty,
     limit_invalid,
+    first_limit_invalid,
     offset_invalid,
     offset_requires_limit,
 });

package/lib/private/db/test.js

@@ -1498,6 +1498,24 @@ export default (db) => {
         assert(yes.length).equals(1);
         assert(yes[0].name).equals("MiXeDCase");
     });
+    $user("first: returns first matching record", async (assert) => {
+        await User.insert({ name: "FirstLow", age: 1 });
+        await User.insert({ name: "FirstHigh", age: 2 });
+        const user = await User.first({
+            where: { name: { $like: "First%" } },
+            sort: { age: "desc" },
+        });
+        assert(user?.name).equals("FirstHigh");
+    });
+    $user("first: returns undefined when no record matches", async (assert) => {
+        const user = await User.first({ where: { name: "MissingFirst" } });
+        assert(user).undefined();
+    });
+    $user$("first: rejects limit", async (assert) => {
+        await throws(assert, Code.first_limit_invalid, () => {
+            return User.first({ limit: 10 });
+        });
+    });
     $user("find: $ilike is case-insensitive", async (assert) => {
         await User.insert({ name: "MiXeDCase2" });
         const rows = await User.find({ where: { name: { $ilike: "mixed%" } } });

package/lib/private/frontend.js

@@ -18,8 +18,9 @@ export default function frontend_module(init) {
     const conditions = init.conditions ?? [];
     const schema = base_schema.extend(init.schema ?? {});
     async function normalize(path) {
-        const file = fs.ref(path);
-        const basename = path.slice(0, -file.fullExtension.length);
+        const extension = init.extensions.find(extension => path.endsWith(extension))
+            ?? fs.ref(path).fullExtension;
+        const basename = path.slice(0, -extension.length);
         return `p_${await hash(`${basename}.${module_name}`)}`;
     }
     return (input) => {
@@ -206,11 +207,11 @@ export default function frontend_module(init) {
                                 build.onLoad({ filter: views_filter }, async () => {
                                     const views = await views_base.files({
                                         recursive: true,
-                                        filter: c => extensions.includes(c.fullExtension),
+                                        filter: c => extensions.some(ext => c.path.endsWith(ext)),
                                     });
                                     const pages = await pages_base.files({
                                         recursive: true,
-                                        filter: c => extensions.includes(c.fullExtension),
+                                        filter: c => extensions.some(ext => c.path.endsWith(ext)),
                                     });
                                     let contents = "";
                                     for (const view of views) {

package/lib/private/response/ResponseFunction.d.ts

@@ -2,9 +2,10 @@ import type View from "#client/View";
 import type RequestFacade from "#request/RequestFacade";
 import type ServeApp from "#serve/App";
 import type { Dict, MaybePromise } from "@rcompat/type";
-type ResponseFunction<Props = unknown> = {
+type ResponseFunction<Props = never, Result = never> = {
     (app: ServeApp, transfer: Dict, request: RequestFacade): MaybePromise<View | null | Response | undefined>;
     readonly _props?: Props;
+    readonly _result?: Result;
 };
 export { ResponseFunction as default };
 //# sourceMappingURL=ResponseFunction.d.ts.map

package/lib/private/response/ResponseLike.d.ts

@@ -1,6 +1,7 @@
 import type ResponseFunction from "#response/ResponseFunction";
 import type Streamable from "@rcompat/fs/Streamable";
 import type { Dict } from "@rcompat/type";
-type ResponseLike = string | Dict | Dict[] | URL | Blob | ReadableStream | Streamable | Response | ResponseFunction<any> | null;
+type UnknownResponseFunction = ResponseFunction<unknown, unknown>;
+type ResponseLike = string | Dict | Dict[] | URL | Blob | ReadableStream | Streamable | Response | UnknownResponseFunction | null;
 export { ResponseLike as default };
 //# sourceMappingURL=ResponseLike.d.ts.map

package/lib/private/response/json.d.ts

@@ -1,9 +1,9 @@
+import type ResponseFunction from "#response/ResponseFunction";
 /**
  * Issue a JSON response
  * @param body body object
  * @param options response options
  * @return Response rendering function
  */
-declare const _default: (body: unknown, init?: ResponseInit) => import("./ResponseFunction.js").default<never>;
-export default _default;
+export default function json<T>(body: T, init?: ResponseInit): ResponseFunction<never, T>;
 //# sourceMappingURL=json.d.ts.map

package/lib/private/response/json.js

@@ -1,10 +1,13 @@
 import response from "#response";
 import http from "@rcompat/http";
+const json_response = response(http.MIME.APPLICATION_JSON, JSON.stringify);
 /**
  * Issue a JSON response
  * @param body body object
  * @param options response options
  * @return Response rendering function
  */
-export default response(http.MIME.APPLICATION_JSON, JSON.stringify);
+export default function json(body, init) {
+    return json_response(body, init);
+}
 //# sourceMappingURL=json.js.map

package/lib/private/response/respond.d.ts

@@ -1,5 +1,6 @@
 import type ResponseFunction from "#response/ResponseFunction";
 import type ResponseLike from "#response/ResponseLike";
+type UnknownResponseFunction = ResponseFunction<unknown, unknown>;
 export default _default;
-declare function _default(result: ResponseLike): ResponseFunction;
+declare function _default(result: ResponseLike): UnknownResponseFunction;
 //# sourceMappingURL=respond.d.ts.map

package/lib/private/route.client.d.ts

@@ -23,8 +23,8 @@ type MethodMeta = {
 type RequestMeta = {
     headers?: HeadersInit;
 };
-type Page<R> = Awaited<R> extends infer Result ? Result extends ResponseFunction<infer Props> ? Props : never : never;
-type ClientResult<R> = Awaited<R> extends infer Result ? Result extends ResponseFunction ? never : Result : never;
+type Page<R> = Awaited<R> extends infer Result ? Result extends ResponseFunction<infer Props, unknown> ? Props : never : never;
+type ClientResult<R> = Awaited<R> extends infer Result ? Result extends ResponseFunction<unknown, infer Payload> ? Payload : Result : never;
 type ClientMethod<O extends RouteOptions, R = unknown> = MethodMeta & {
     _result?: ClientResult<R>;
     Page: Page<R>;

package/lib/private/route.d.ts

@@ -11,7 +11,7 @@ type WithResult<O extends RouteOptions, R extends ResponseLike> = {
     handler: RouteHandler<O, R>;
     options: O;
 };
-type Page<R> = Awaited<R> extends infer Result ? Result extends ResponseFunction<infer Props> ? Props : never : never;
+type Page<R> = Awaited<R> extends infer Result ? Result extends ResponseFunction<infer Props, unknown> ? Props : never : never;
 type AnyHandler = RouteHandler | WithResult<RouteOptions, ResponseLike>;
 type RouteHandlers = {
     [key in Method]?: AnyHandler;

package/lib/private/store/Store.d.ts

@@ -179,6 +179,17 @@ export default class Store<T extends StoreInput, N extends string = string> impl
         offset?: number;
         with?: W;
     }): Promise<WithRelations<Projected<Schema<T>, S>, ExtractRelations<T>, W>[]>;
+    /**
+     * Find the first matching record.
+     */
+    first<const S extends Select<Schema<T>> | undefined = undefined, const W extends WithInput<ExtractRelations<T>> | undefined = undefined>(options?: {
+        where?: Where<T>;
+        select?: S;
+        sort?: Sort<Schema<T>>;
+        offset?: number;
+        with?: W;
+        limit?: never;
+    }): Promise<WithRelations<Projected<Schema<T>, S>, ExtractRelations<T>, W> | undefined>;
     toJSON(): {
         type: "object";
         properties: Dict<import("pema").Serialized>;

package/lib/private/store/Store.js

@@ -590,6 +590,16 @@ export default class Store {
         });
         return result;
     }
+    /**
+     * Find the first matching record.
+     */
+    async first(options) {
+        guard_options(options, ["where", "select", "sort", "offset", "with", "limit"]);
+        if (is.defined(options?.limit))
+            throw E.first_limit_invalid();
+        const [first] = await this.find({ ...options, limit: 1 });
+        return first;
+    }
     toJSON() {
         return this.#schema.toJSON();
     }

package/lib/public/response.d.ts

@@ -1,12 +1,13 @@
 import binary from "#response/binary";
 import error from "#response/error";
+import json from "#response/json";
 import page from "#response/page";
 import view from "#response/view";
 import $null from "#response/null";
 declare const response: {
     binary: typeof binary;
     error: typeof error;
-    json: (body: unknown, init?: ResponseInit) => import("./index.js").ResponseFunction<never>;
+    json: typeof json;
     page: typeof page;
     redirect: (location: string, status?: 300 | 301 | 302 | 303 | 304 | 307 | 308) => import("./index.js").ResponseFunction<never>;
     sse: (body: (source: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@primate/core",
-  "version": "0.9.4",
+  "version": "0.9.6",
   "description": "The universal web framework",
   "homepage": "https://primate.run",
   "bugs": "https://github.com/primate-run/primate/issues",