Fixed inserted by _id when _id is provided

src/packages/pongo/src/core/collection/pongoCollection.ts

@@ -91,10 +91,10 @@ export const pongoCollection = <
     ): Promise<PongoInsertOneResult> => {
       await createCollection(options);
 
-      const _id = uuid();
+      const _id = (document._id as string | undefined | null) ?? uuid();
 
       const result = await command(
-        SqlFor.insertOne({ _id, ...document } as OptionalUnlessRequiredId<T>),
+        SqlFor.insertOne({ ...document, _id } as OptionalUnlessRequiredId<T>),
         options,
       );
 
@@ -108,15 +108,15 @@ export const pongoCollection = <
     ): Promise<PongoInsertManyResult> => {
       await createCollection(options);
 
-      const rows = documents.map(
-        (doc) =>
-          ({
-            _id: uuid(),
-            ...doc,
-          }) as OptionalUnlessRequiredId<T>,
-      );
+      const rows = documents.map((doc) => ({
+        ...doc,
+        _id: (doc._id as string | undefined | null) ?? uuid(),
+      }));
 
-      const result = await command(SqlFor.insertMany(rows), options);
+      const result = await command(
+        SqlFor.insertMany(rows as OptionalUnlessRequiredId<T>[]),
+        options,
+      );
 
       return {
         acknowledged: result.rowCount === rows.length,

src/packages/pongo/src/core/typing/operations.ts

@@ -169,13 +169,13 @@ export declare type EnhancedOmit<TRecordOrUnion, KeyUnion> =
       : never;
 export declare type OptionalUnlessRequiredId<TSchema> = TSchema extends {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  _id: any;
+  _id: string | ObjectId;
 }
   ? TSchema
   : OptionalId<TSchema>;
 
 export declare type WithId<TSchema> = EnhancedOmit<TSchema, '_id'> & {
-  _id: InferIdType<TSchema>;
+  _id: string | ObjectId;
 };
 
 export type WithoutId<T> = Omit<T, '_id'>;
@@ -189,11 +189,11 @@ export declare interface Document {
 }
 
 export declare type OptionalId<TSchema> = EnhancedOmit<TSchema, '_id'> & {
-  _id?: InferIdType<TSchema>;
+  _id?: string | ObjectId;
 };
 
 export declare interface ObjectIdLike {
-  __id?: string;
+  __id?: string | ObjectId;
 }
 
 export declare type NonObjectIdLikeDocument = {

src/packages/pongo/src/e2e/postgres.e2e.spec.ts

@@ -30,6 +30,13 @@ type User = {
   tags?: string[];
 };
 
+type UserWithoutId = {
+  name: string;
+  age: number;
+  address?: Address;
+  tags?: string[];
+};
+
 void describe('MongoDB Compatibility Tests', () => {
   let postgres: StartedPostgreSqlContainer;
   let postgresConnectionString: string;
@@ -65,6 +72,39 @@ void describe('MongoDB Compatibility Tests', () => {
   });
 
   void describe('Insert Operations', () => {
+    void it('should insert a document with id into both PostgreSQL and MongoDB', async () => {
+      const pongoCollection = pongoDb.collection<User>('insertOne');
+      const mongoCollection = mongoDb.collection<User>('shiminsertOne');
+      const _id = new Date().toISOString();
+      const doc: User = {
+        _id: new Date().toISOString(),
+        name: 'Anita',
+        age: 25,
+      };
+      const pongoInsertResult = await pongoCollection.insertOne(doc);
+      const mongoInsertResult = await mongoCollection.insertOne(doc);
+      assert(pongoInsertResult.insertedId);
+      assert(mongoInsertResult.insertedId);
+      const pongoDoc = await pongoCollection.findOne({
+        _id: pongoInsertResult.insertedId,
+      });
+      const mongoDoc = await mongoCollection.findOne({
+        _id: mongoInsertResult.insertedId,
+      });
+      assert.ok(pongoDoc);
+      assert.ok(mongoDoc);
+      assert.deepStrictEqual(
+        {
+          name: pongoDoc.name,
+          age: pongoDoc.age,
+        },
+        {
+          name: mongoDoc.name,
+          age: mongoDoc.age,
+        },
+      );
+    });
+
     void it('should insert a document into both PostgreSQL and MongoDB', async () => {
       const pongoCollection = pongoDb.collection<User>('insertOne');
       const mongoCollection = mongoDb.collection<User>('shiminsertOne');