Is there some difference between types of PgDatabase and PgliteDatabase ?

[arvinxx]

I'm trying to do a system of client db with pglite, and server db with postgres. And I want to share schema and models between client and server. So I create a model like this:

export class TopicModel {
  private userId: string;
  private db: LobeChatDatabase;

  constructor(db: LobeChatDatabase, userId: string) {
    this.userId = userId;
    this.db = db;
  }

  async findById(id: string) {
    return this.db.query.topics.findFirst({
      where: and(eq(topics.id, id), eq(topics.userId, this.userId)),
    });
  }

And in the server side, I can init server db and pass the instance to model like this:

// server db

import { Pool as NeonPool } from '@neondatabase/serverless';
import { NeonDatabase, drizzle as neonDrizzle } from 'drizzle-orm/neon-serverless';
import { Pool as NodePool } from 'pg';

import * as schema from '../../schemas';

export const getDBInstance = (): NeonDatabase<typeof schema> => {

  const client = new NeonPool({ connectionString: process.env.DATABASE_URL });
  return neonDrizzle(client, { schema });
};

export const serverDB = getDBInstance();

// router
const topicModel = new TopicModel(serverDB, ctx.userId)

const data = await topicModel.batchCreate(input);

And in the client side, I want to use same way:

// client db
import { IdbFs, PGlite } from '@electric-sql/pglite';
import { vector } from '@electric-sql/pglite/vector';
import { drizzle } from 'drizzle-orm/pglite';

import * as schema from '../schemas';

const client = new PGlite({
  extensions: { vector },
  fs: new IdbFs('lobechat'),
  relaxedDurability: true,
});

export const clientDB = drizzle({ client, schema });

// client service
export class ClientService {
  private topicModel: TopicModel;
  constructor(userId) {

    this.topicModel = new TopicModel(clientDB, userId);
  }

  async createTopic(params: CreateTopicParams): Promise<string> {
    const item = await this.topicModel.create(params as any);

    if (!item) {
      throw new Error('topic create Error');
    }

    return item.id;
  }

now the core issue is that I defined the LobeChatDatabase :

import type { NeonDatabase } from 'drizzle-orm/neon-serverless';

import * as schema from './schemas';

export type LobeChatDatabaseSchema = typeof schema;

export type LobeChatDatabase = NeonDatabase<LobeChatDatabaseSchema>;

it works correctly in the server db as it should be. But in the client service, it just show an error:

TS2345: Argument of type
PgliteDatabase<typeof import(" lobe-chat/ src/ database/ schemas/ index")> & {     $client: PGlite; }
is not assignable to parameter of type LobeChatDatabase
The types of _.session are incompatible between these types.
Type 'PgSession<PgliteQueryResultHKT, typeof import(" lobe-chat/ src/ database/ schemas/ index"), ExtractTablesWithRelations<typeof import(" lobe-chat/ src/ database/ schemas/ index")>>' is not assignable to type 'PgSession<NeonQueryResultHKT, typeof import(" lobe-chat/ src/ database/ schemas/ index"), ExtractTablesWithRelations<typeof import(" lobe-chat/ src/ database/ schemas/ index")>>'.
Type PgliteQueryResultHKT is not assignable to type NeonQueryResultHKT
Types of property type are incompatible.
Type Results<{ [key: string]: any; }> is missing the following properties from type QueryResult<QueryResultRow>: command, rowCount, oid

it shows that command, rowCount, oid key is not in the PgliteQueryResult

Is this a bug or by design? I thought it shouldn't be difference in query result between pglite and postgres, am I wrong?

Thanks for help.