test: add two-way unique one-to-one relations tests

Author: kettanaito

src/collection.ts

@@ -131,8 +131,9 @@ export class Collection<Schema extends StandardSchemaV1> {
 
     if (validationResult.issues) {
       console.error(validationResult.issues)
+
       throw new OperationError(
-        'Failed to create a new record with initial values (%j): does not match the schema. Please see the schema validation errors above.',
+        'Failed to create a new record with initial values: does not match the schema. Please see the schema validation errors above.',
         OperationErrorCodes.INVALID_INITIAL_VALUES,
       )
     }

src/relation.ts

@@ -359,7 +359,7 @@ export abstract class Relation {
             this.#createErrorDetails(),
           ),
           isUnique,
-          `Failed to create a unique relation at "%s": foreign ${this instanceof Many ? 'records' : 'record'} already associated with another owner`,
+          `Failed to create a unique relation at "%s": the foreign ${this instanceof Many ? 'records' : 'record'} is already associated with another owner`,
           serializedPath,
         )
 

tests/relations/one-to-one.test.ts

@@ -241,7 +241,7 @@ it('applies relation to records created before the relation is defined', async (
   })
 })
 
-it('supports creating unique one-to-one relations', async () => {
+it('supports creating unique one-way one-to-one relations', async () => {
   const userSchema = z.object({ id: z.number() })
   const postSchema = z.object({
     title: z.string(),
@@ -290,7 +290,7 @@ it('supports creating unique one-to-one relations', async () => {
   })
 })
 
-it('supports updating unique one-to-one relations', async () => {
+it('supports updating unique one-way one-to-one relations', async () => {
   const userSchema = z.object({ id: z.number() })
   const postSchema = z.object({
     title: z.string(),
@@ -328,7 +328,7 @@ it('supports updating unique one-to-one relations', async () => {
   })
 })
 
-it('errors when creating a unique relation with a foreign record that has already been associated', async () => {
+it('errors when creating a unique one-way relation referencing a taken foreign record', async () => {
   const userSchema = z.object({ id: z.number() })
   const postSchema = z.object({
     title: z.string(),
@@ -360,7 +360,7 @@ it('errors when creating a unique relation with a foreign record that has alread
   )
 })
 
-it('errors when updating a unique relation with a foreign record that has already been associated', async () => {
+it('errors when updating a unique one-way relation referencing a taken foreign record', async () => {
   const userSchema = z.object({ id: z.number() })
   const postSchema = z.object({
     title: z.string(),
@@ -398,3 +398,168 @@ it('errors when updating a unique relation with a foreign record that has alread
     ),
   )
 })
+
+it('supports creating unique two-way one-to-one relations', async () => {
+  const userSchema = z.object({
+    id: z.number(),
+    get favoritePost() {
+      return postSchema
+    },
+  })
+  const postSchema = z.object({
+    title: z.string(),
+    get author() {
+      return userSchema.optional()
+    },
+  })
+
+  const users = new Collection({ schema: userSchema })
+  const posts = new Collection({ schema: postSchema })
+
+  users.defineRelations(({ one }) => ({
+    favoritePost: one(posts, { unique: true }),
+  }))
+  posts.defineRelations(({ one }) => ({
+    author: one(users, { unique: true }),
+  }))
+
+  const user = await users.create({
+    id: 1,
+    favoritePost: await posts.create({ title: 'First' }),
+  })
+  expect(user.favoritePost).toEqual({ title: 'First', author: user })
+  expect(posts.findFirst((q) => q.where({ author: { id: 1 } }))).toEqual({
+    title: 'First',
+    author: user,
+  })
+})
+
+it('errors when creating a unique two-way relation referencing a taken foreign record', async () => {
+  const userSchema = z.object({
+    id: z.number(),
+    get favoritePost() {
+      return postSchema.optional()
+    },
+  })
+  const postSchema = z.object({
+    title: z.string(),
+    get author() {
+      return userSchema.optional()
+    },
+  })
+
+  const users = new Collection({ schema: userSchema })
+  const posts = new Collection({ schema: postSchema })
+
+  users.defineRelations(({ one }) => ({
+    favoritePost: one(posts, { unique: true }),
+  }))
+  posts.defineRelations(({ one }) => ({
+    author: one(users, { unique: true }),
+  }))
+
+  const user = await users.create({
+    id: 1,
+    favoritePost: await posts.create({ title: 'First' }),
+  })
+
+  await expect(
+    users.create({ id: 2, favoritePost: user.favoritePost }),
+  ).rejects.toThrow(
+    new RelationError(
+      `Failed to create a unique relation at "favoritePost": the foreign record is already associated with another owner`,
+      RelationErrorCodes.FORBIDDEN_UNIQUE_CREATE,
+      {
+        path: ['favoritePost'],
+        ownerCollection: users,
+        foreignCollections: [posts],
+        options: { unique: true },
+      },
+    ),
+  )
+
+  await expect(posts.create({ title: 'Second', author: user })).rejects.toThrow(
+    new RelationError(
+      `Failed to create a unique relation at "author": the foreign record is already associated with another owner`,
+      RelationErrorCodes.FORBIDDEN_UNIQUE_CREATE,
+      {
+        path: ['author'],
+        ownerCollection: posts,
+        foreignCollections: [users],
+        options: { unique: true },
+      },
+    ),
+  )
+})
+
+it('errors when updating a unique two-way relation referencing a taken foreign record', async () => {
+  const userSchema = z.object({
+    id: z.number(),
+    get favoritePost() {
+      return postSchema
+    },
+  })
+  const postSchema = z.object({
+    title: z.string(),
+    get author() {
+      return userSchema.optional()
+    },
+  })
+
+  const users = new Collection({ schema: userSchema })
+  const posts = new Collection({ schema: postSchema })
+
+  users.defineRelations(({ one }) => ({
+    favoritePost: one(posts, { unique: true }),
+  }))
+  posts.defineRelations(({ one }) => ({
+    author: one(users, { unique: true }),
+  }))
+
+  const firstUser = await users.create({
+    id: 1,
+    favoritePost: await posts.create({ title: 'First' }),
+  })
+  const secondUser = await users.create({
+    id: 2,
+    favoritePost: await posts.create({ title: 'Second' }),
+  })
+
+  await expect(
+    users.update(secondUser, {
+      data(user) {
+        user.favoritePost = firstUser.favoritePost
+      },
+    }),
+  ).rejects.toThrow(
+    new RelationError(
+      `Failed to update a unique relation at "favoritePost": the foreign record is already associated with another owner`,
+      RelationErrorCodes.FORBIDDEN_UNIQUE_UPDATE,
+      {
+        path: ['favoritePost'],
+        ownerCollection: users,
+        foreignCollections: [posts],
+        options: { unique: true },
+      },
+    ),
+  )
+
+  await expect(
+    posts.update((q) => q.where({ author: { id: 2 } }), {
+      data(post) {
+        post.author = firstUser
+      },
+    }),
+  ).rejects.toThrow(
+    new RelationError(
+      `Failed to update a unique relation at "author": the foreign record is already associated with another owner`,
+      RelationErrorCodes.FORBIDDEN_UNIQUE_UPDATE,
+      {
+        path: ['author'],
+        ownerCollection: posts,
+        foreignCollections: [users],
+        options: { unique: true },
+      },
+    ),
+  )
+})