@primate/core 0.9.10 → 0.9.12

package/lib/private/db/test.js

@@ -132,6 +132,29 @@ export default (db) => {
             name: p.string.default("Donald"),
         },
     });
+    test.case("insert type accepts explicit undefined for write-optional fields", assert => {
+        const insert = {
+            age: undefined,
+            id: undefined,
+            name: undefined,
+            lastname: undefined,
+        };
+        assert(insert).type();
+        User.insert({
+            age: undefined,
+            id: undefined,
+            name: undefined,
+            lastname: undefined,
+        });
+    });
+    test.case("insert type survives omit", assert => {
+        const insert = {
+            age: undefined,
+            id: undefined,
+            lastname: undefined,
+        };
+        assert(insert).type();
+    });
     const UserN = store({
         table: "user_n",
         db,
@@ -317,7 +340,9 @@ export default (db) => {
         });
     }
     function bad_where(label, mk, expected) {
-        return security_pair("where", label, mk, base => User.find({ where: base }), w => Author.find({ with: { articles: { store: Article, where: w } } }), expected);
+        return security_pair("where", label, mk, base => User.find({ where: base }), w => Author.find({
+            with: { articles: { store: Article, where: w } },
+        }), expected);
     }
     function bad_select(label, mk, expected) {
         return security_pair("find", label, mk, base => User.find({ select: base }), w => Author.find({ with: { articles: { store: Article, select: w } } }), expected);
@@ -1084,7 +1109,9 @@ export default (db) => {
         //const missing = `missing-${Date.now()}-${Math.random()}`;
         const missing = "00000000-0000-4000-8000-000000000000";
         await throws(assert, Code.record_not_found, () => Article.get(missing, { with: { author: Author } }));
-        assert(await Article.try(missing, { with: { author: Author } })).undefined();
+        assert(await Article.try(missing, {
+            with: { author: Author },
+        })).undefined();
     });
     $rel("get/try: missing id (+ parent)", async (assert) => {
         const missing = "00000000-0000-4000-8000-000000000000";
@@ -1287,7 +1314,8 @@ export default (db) => {
         assert(rows.length).equals(1);
         assert(rows[0].id).equals(u.id);
     });
-    /*$store("json column: inferred type on insert", AuthorWithJSON, async assert => {
+    /*$store("json column: inferred type on insert", AuthorWithJSON,
+     async assert => {
       const author = await AuthorWithJSON.insert({
         name: "John",
         articles: [{ title: "First", published: new Date() }],
@@ -1322,7 +1350,9 @@ export default (db) => {
       });
       const author = await AuthorWithJSON.get(a.id);
   
-      assert(author.articles).type<{ title: string; published: Date }[] | undefined>();
+      assert(author.articles).type<{
+        title: string; published: Date
+      }[] | undefined>();
       assert(author.meta).type<{ views: number; tags: string[] } | undefined>();
       assert(author.notes).type<JSONValue | undefined>();
   
@@ -1331,7 +1361,8 @@ export default (db) => {
       assert(author.articles?.[0].published).type<Date | undefined>();
     });
   
-    $store("json column: roundtrip preserves types", AuthorWithJSON, async assert => {
+    $store("json column: roundtrip preserves types", AuthorWithJSON,
+      async assert => {
       const now = new Date();
       const a = await AuthorWithJSON.insert({
         name: "John",
@@ -1354,7 +1385,9 @@ export default (db) => {
       await AuthorWithJSON.find({ where: { meta: { tags: { $like: "%ts%" } } } });
   
       // $contains always available, untyped
-      await AuthorWithJSON.find({ where: { articles: { $contains: { title: "First" } } } });
+      await AuthorWithJSON.find({ where: {
+        articles: { $contains: { title: "First" } } },
+      });
     });*/
     $user("where: null matches unset via update", async (assert) => {
         const [paul] = await User.find({ where: { name: "Paul" } });
@@ -1571,7 +1604,7 @@ export default (db) => {
             select: ["name"],
             with: {
                 articles: {
-                    store: Article, select: ["title"], sort: { title: "asc" }
+                    store: Article, select: ["title"], sort: { title: "asc" },
                 },
             },
             sort: { name: "asc" },
@@ -1622,7 +1655,9 @@ export default (db) => {
                 id: key.primary(p.uuid),
                 parent_id: key.foreign(p.uuid),
                 url: p.url.optional(),
-                parent: relation.one({ table: "j_parent", by: "parent_id", reverse: true }),
+                parent: relation.one({
+                    table: "j_parent", by: "parent_id", reverse: true,
+                }),
             },
         });
         await Parent.create();
@@ -1636,7 +1671,7 @@ export default (db) => {
                 parent_id: p0.id,
                 url: new URL("https://example.com/joined"),
             });
-            // IMPORTANT: force joined path + projection that omits pk, but still must join.
+            // force joined path + projection that omits pk, but still must join
             const [got] = await Parent.find({
                 where: { id: p0.id },
                 select: ["url"],
@@ -1645,11 +1680,12 @@ export default (db) => {
             assert(got).defined();
             // pk must not leak
             assert("id" in got).false();
-            // ---- base assertion (should fail if joined base isn't unbound/decoded)
+            // base assertion (should fail if joined base isn't unbound/decoded)
             assert(got.url).type();
             assert(got.url instanceof URL).true();
             assert(got.url.href).equals("https://example.com/parent");
-            // ---- relation assertion (should fail if joined relation isn't unbound/decoded)
+            // relation assertion (should fail if joined relation isn't
+            // unbound/decoded)
             assert(Array.isArray(got.children)).true();
             assert(got.children.length).equals(1);
             const c0 = got.children[0];
@@ -1912,7 +1948,7 @@ export default (db) => {
     $user("find: offset skips records", async (assert) => {
         const all = await User.find({ sort: { name: "asc" } });
         const offset = await User.find({
-            sort: { name: "asc" }, offset: 2, limit: all.length - 2
+            sort: { name: "asc" }, offset: 2, limit: all.length - 2,
         });
         assert(offset.length).equals(all.length - 2);
         assert(offset[0].name).equals(all[2].name);
@@ -1920,7 +1956,7 @@ export default (db) => {
     $user("find: offset 0 is same as no offset", async (assert) => {
         const without = await User.find({ sort: { name: "asc" } });
         const with_zero = await User.find({
-            sort: { name: "asc" }, offset: 0, limit: without.length
+            sort: { name: "asc" }, offset: 0, limit: without.length,
         });
         assert(with_zero.length).equals(without.length);
         assert(with_zero.map(r => r.name)).equals(without.map(r => r.name));

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

@@ -8,7 +8,7 @@ import type Init from "#store/Init";
 import type PrimaryKey from "#store/PrimaryKey";
 import type { ManyRelation, OneRelation, Relation } from "#store/relation";
 import type StoreInput from "#store/StoreInput";
-import type { Dict, Serializable } from "@rcompat/type";
+import type { Dict, Serializable, Unpack } from "@rcompat/type";
 import type { DefaultType, InferStore, Storable } from "pema";
 import StoreType from "pema/StoreType";
 declare const brand: unique symbol;
@@ -18,9 +18,6 @@ type X<T> = {
 type OrNull<T> = {
     [P in keyof T]?: null | T[P] | undefined;
 };
-type Optional<T> = {
-    [P in keyof T]?: T[P] | undefined;
-};
 type StringOperators = {
     $like?: string;
     $ilike?: string;
@@ -62,7 +59,7 @@ type Projected<T, S extends Select<T> | undefined> = S extends readonly (keyof T
 type DefaultFields<T extends StoreInput> = {
     [K in keyof InferRecord<T>]: T[K] extends DefaultType<any, any> ? K : never;
 }[keyof InferRecord<T>];
-type Insertable<T extends StoreInput> = X<Omit<InferRecord<T>, PrimaryKeyField<T> | DefaultFields<T>> & Optional<Pick<InferRecord<T>, PrimaryKeyField<T> | DefaultFields<T>>>>;
+type Insertable<T extends StoreInput> = Omit<InferRecord<T>, PrimaryKeyField<T> | DefaultFields<T>> & Partial<Pick<InferRecord<T>, PrimaryKeyField<T> | DefaultFields<T>>>;
 type PrimaryKeyField<T extends StoreInput> = {
     [K in keyof T]: T[K] extends PrimaryKey<any> ? K : never;
 }[keyof T] & keyof InferRecord<T>;
@@ -100,7 +97,7 @@ type ReadSort = Dict<"asc" | "desc">;
 export default class Store<T extends StoreInput, N extends string = string> implements Serializable {
     #private;
     [brand]: boolean;
-    readonly Insert: Insertable<T>;
+    readonly Insert: Unpack<Insertable<T>>;
     readonly Schema: Schema<T>;
     static is(x: unknown): x is Store<any, any>;
     constructor(init: Init<T, N>);

package/lib/private/store.d.ts

@@ -3,7 +3,9 @@ import key from "#store/key";
 import relation from "#store/relation";
 import Store from "#store/Store";
 import type StoreInput from "#store/StoreInput";
-declare function store<T extends StoreInput, const N extends string = string>(init: Init<T, N>): Store<T, N>;
+declare function store<T extends StoreInput, const N extends string = string>(init: Omit<Init<T, N>, "schema"> & {
+    schema: T;
+}): Store<T, N>;
 declare namespace store {
     export { key };
     export { relation };

package/package.json

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