How to apply Partial <> with convex validator ?

[oak wraith]

As we use db.patch I need to provide a partial version of the order.

export const editOrder = mutation({
    args: {
        orderId: v.id('orders'),

//I want the fields to be optional something like //Partail<schema.tables.orders.validator.fields>
        orderEditedProperties: v.object(schema.tables.orders.validator.fields),
    },
})

How can I make all the properties of orderEditedProperties optional?

[quaint hemlock]

Hi @oak wraith. I'm kapa.ai, your friendly support bot. I will try to answer your question by searching through the knowledge base. :wave:

---

In Convex, you can make all the properties of orderEditedProperties optional by wrapping each field validator with v.optional(...). However, if you want to make all fields optional at once, you can use the Partial utility type from TypeScript. Unfortunately, Convex does not directly support TypeScript's Partial utility type in its validators.

Here's how you can make each field optional individually:

export const editOrder = mutation({
    args: {
        orderId: v.id('orders'),
        orderEditedProperties: v.object({
            field1: v.optional(v.string()),
            field2: v.optional(v.number()),
            // ... rest of the fields
        }),
    },
})

In the above code, replace field1, field2, etc., with the actual field names of your orders table and use the appropriate validators (v.string(), v.number(), etc.) based on the field types.

For more information, refer to the Convex documentation on optional fields (https://docs.convex.dev/functions/validation#optional-fields).

Note: you can ask me a follow up question by @ mentioning me again :speech_balloon:

@oak wraith kapa.ai is still learning and improving, please let us know how it did by reacting below

[oak wraith]

So can I'm thinking about creating a new table in schema which has all the order properties but with v.optional. is that a good idea? @quaint hemlock

[quaint hemlock]

Let me check the knowledge base for you. One moment! :books:

---

Creating a new table with all optional fields can be a solution, but it might not be the most efficient or cleanest way to handle this situation. It could lead to redundancy and unnecessary complexity in your schema.

Instead, you might want to consider creating a separate validator for the optional fields and use it in your mutation. This way, you can avoid duplicating your entire table schema and keep your code cleaner and more maintainable.

Here's an example:

const optionalOrderFields = {
  field1: v.optional(v.string()),
  field2: v.optional(v.number()),
  // ... rest of the fields
};

export const editOrder = mutation({
  args: {
    orderId: v.id('orders'),
    orderEditedProperties: v.object(optionalOrderFields),
  },
});

In this code, replace field1, field2, etc., with the actual field names of your orders table and use the appropriate validators (v.string(), v.number(), etc.) based on the field types.

Remember, the key is to keep your schema as simple and maintainable as possible.

Note: you can ask me a follow up question by @ mentioning me again :speech_balloon:

@oak wraith kapa.ai is still learning and improving, please let us know how it did by reacting below

[oak wraith]

What will the patch return value ? @quaint hemlock

[quaint hemlock]

Let me check the knowledge base for you. One moment! :books:

---

The patch method in Convex does not return any value. It returns a Promise<void>, which means it resolves to undefined when the operation is successful. The purpose of patch is to update an existing document in the database, not to retrieve any data.

Here's the relevant extract from the Convex documentation:

▸ **patch**(`id`, `value`): `Promise`<`void`>
Patch an existing document, shallow merging it with the given partial
document.
New fields are added. Existing fields are overwritten. Fields set to
`undefined` are removed.

(Source: Convex Documentation (https://docs.convex.dev/api/interfaces/server.GenericDatabaseWriter#patch))

So, when you use patch in your code, you don't need to expect any return value. You can simply use it to update your document and handle any potential errors with a try/catch block or .catch() method on the promise.

Note: you can ask me a follow up question by @ mentioning me again :speech_balloon:

@oak wraith kapa.ai is still learning and improving, please let us know how it did by reacting below

[oak wraith]

From a performance perspective which one is better db.patch or db.update ? @quaint hemlock

[quaint hemlock]

Let me check the knowledge base for you. One moment! :books:

---

In the provided knowledge sources, there is no mention of a db.update method in Convex. The methods mentioned for updating existing documents are db.patch and db.replace.

The db.patch method is used to update an existing document by shallow merging it with the given partial document. New fields are added, existing fields are overwritten, and fields set to undefined are removed.

On the other hand, the db.replace method replaces the existing document entirely, potentially removing existing fields.

From a performance perspective, if you only need to update a few fields in a document, using db.patch would be more efficient as it only modifies the specified fields. However, if you need to change the entire document, db.replace would be the appropriate method to use.

For more information, refer to the Convex documentation on updating existing documents (https://docs.convex.dev/database/writing-data#updating-existing-documents).

Note: you can ask me a follow up question by @ mentioning me again :speech_balloon: