@primate/core 0.9.5 → 0.9.7

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

@@ -2,6 +2,7 @@ import type Mode from "#Mode";
 import type RequestView from "#request/RequestView";
 import type { Dict } from "@rcompat/type";
 type ClientData<T extends Dict = Dict> = {
+    frontend: string;
     view: string;
     request: RequestView;
     csr: boolean;

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

@@ -1,5 +1,5 @@
 import type { Updater } from "#client/root";
 import type { Dict } from "@rcompat/type";
 export default _default;
-declare function _default<T extends Dict>(u: Updater<T>): void;
+declare function _default<T extends Dict>(frontend: string, u: Updater<T>): void;
 //# sourceMappingURL=boot.d.ts.map

package/lib/private/client/boot.js

@@ -3,8 +3,8 @@ import root from "#client/root";
 import storage from "#client/storage";
 import submit from "#client/submit";
 import http from "@rcompat/http";
-export default (u) => {
-    root.set(u);
+export default (frontend, u) => {
+    root.set(u, frontend);
     const { location, history } = globalThis;
     if (document.contentType === "application/json") {
         location.reload();

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

@@ -11,7 +11,7 @@ import type ValidateUpdater from "#client/ValidateUpdater";
 import type ValidationError from "#client/ValidationError";
 import type ViewResponse from "#client/ViewResponse";
 declare const client: {
-    boot: <T extends import("@rcompat/type").Dict>(u: import("./root.js").Updater<T>) => void;
+    boot: <T extends import("@rcompat/type").Dict>(frontend: string, u: import("./root.js").Updater<T>) => void;
     navigate: (href: string, event?: Event) => Promise<void>;
     submit: typeof submit;
     createForm: typeof createForm;

package/lib/private/client/navigate.js

@@ -21,8 +21,14 @@ async function goto(target, state = false, after) {
         const path = target.pathname + target.search;
         const { requested, response } = await transport.refetch(path, { headers });
         if (transport.is_json(response)) {
-            if (response.ok)
-                root.update(await response.json());
+            if (response.ok) {
+                const data = await response.json();
+                if (!root.same(data)) {
+                    location.assign(requested.toString() + target.hash);
+                    return;
+                }
+                root.update(data);
+            }
             if (state) {
                 storage.new({ hash: location.hash, pathname: location.pathname, scrollTop });
                 history.pushState({}, "", `${path}${target.hash}`);

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

@@ -2,7 +2,8 @@ import type ClientData from "#client/Data";
 import type { Dict } from "@rcompat/type";
 export type Updater<T extends Dict> = (json: ClientData<T>, after?: () => void) => void;
 declare const root: {
-    set(updater: Updater<any>): void;
+    set(updater: Updater<any>, name: string): void;
+    same(data: ClientData): boolean;
     update(data: any, after?: () => void): void;
 };
 export default root;

package/lib/private/client/root.js

@@ -1,7 +1,12 @@
 let current;
+let frontend;
 const root = {
-    set(updater) {
+    set(updater, name) {
         current = updater;
+        frontend = name;
+    },
+    same(data) {
+        return data.frontend === frontend;
     },
     update(data, after) {
         current(data, after);

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) => {
@@ -57,7 +58,7 @@ export default function frontend_module(init) {
             if (app_asset === undefined)
                 throw E.frontend_missing_app_js();
             const app_script = `<script type="module" src="${app_asset.src}"></script>`;
-            const props = JSON.stringify({ frontend: init.name, ...client });
+            const props = JSON.stringify(client);
             const hydrated = await inline(props, http.MIME.APPLICATION_JSON, "hydration");
             const script_src = [hydrated.integrity];
             return {
@@ -83,6 +84,7 @@ export default function frontend_module(init) {
                     }
                     : { props, request: $request };
                 const client = {
+                    frontend: init.name,
                     view: init.layouts ? "root" : await normalize(view),
                     csr,
                     ssr: ssr(),
@@ -206,11 +208,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.7",
   "description": "The universal web framework",
   "homepage": "https://primate.run",
   "bugs": "https://github.com/primate-run/primate/issues",