@primate/core 0.9.9 → 0.9.11

package/lib/private/db/test.js

@@ -317,7 +317,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 +1086,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 +1291,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 +1327,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 +1338,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 +1362,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 +1581,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 +1632,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 +1648,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 +1657,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 +1925,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 +1933,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

@@ -16,8 +16,17 @@ type X<T> = {
     [K in keyof T]: T[K];
 } & {};
 type OrNull<T> = {
-    [P in keyof T]?: null | T[P];
+    [P in keyof T]?: null | T[P] | undefined;
 };
+type Optional<T> = {
+    [P in keyof T]?: T[P] | undefined;
+};
+type OptionalKeys<T> = {
+    [K in keyof T]-?: object extends Pick<T, K> ? K : never;
+}[keyof T];
+type UndefinedOptional<T> = X<Omit<T, OptionalKeys<T>> & {
+    [K in OptionalKeys<T>]?: T[K] | undefined;
+}>;
 type StringOperators = {
     $like?: string;
     $ilike?: string;
@@ -59,7 +68,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> = Omit<InferRecord<T>, PrimaryKeyField<T> | DefaultFields<T>> & Partial<Pick<InferRecord<T>, PrimaryKeyField<T> | DefaultFields<T>>>;
+type Insertable<T extends StoreInput> = UndefinedOptional<Omit<InferRecord<T>, PrimaryKeyField<T> | DefaultFields<T>> & Optional<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>;

package/lib/private/store/Store.js

@@ -24,6 +24,10 @@ function guard_options(options, allowed) {
             throw E.option_unknown(k);
     }
 }
+function strip_undefined(record) {
+    return Object.fromEntries(Object.entries(record)
+        .filter(([, value]) => value !== undefined));
+}
 const INT_LIMITS = {
     u8: [0, 255],
     u16: [0, 65535],
@@ -512,15 +516,18 @@ export default class Store {
      */
     async insert(record) {
         assert.dict(record);
-        const prepared = this.#prepare_insert(record);
+        const prepared = this.#prepare_insert(strip_undefined(record));
         return this.db.create(this.#as, this.#schema.parse(prepared));
     }
     async update(arg0, options) {
         const by_pk = options !== undefined;
-        const set = by_pk
+        const input_set = by_pk
             ? options.set
             : arg0.set;
-        if (!is.dict(set) || is.empty(set))
+        if (!is.dict(input_set))
+            throw E.set_empty();
+        const set = strip_undefined(input_set);
+        if (is.empty(set))
             throw E.set_empty();
         const pk = this.#pk;
         if (pk !== null && pk in set)

package/package.json

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