@primate/core 0.9.5 → 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/json.d.ts

@@ -5,5 +5,5 @@ import type ResponseFunction from "#response/ResponseFunction";
  * @param options response options
  * @return Response rendering function
  */
-export default function json<const T>(body: T, init?: ResponseInit): ResponseFunction<never, T>;
+export default function json<T>(body: T, init?: ResponseInit): ResponseFunction<never, T>;
 //# sourceMappingURL=json.d.ts.map

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/package.json

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