Raw tables require the Rust-based sync client. The JS client will ignore them.

[ivanvolti]

I'm seeing this warning in the console:
"Raw tables require the Rust-based sync client. The JS client will ignore them."

I'm not sure what's triggering it. Do I need to take any action here?

Just for more context, here's how I create db:

import { BackendConnector } from '@/db/powersync/connector';
import { wrapPowerSyncWithDrizzle } from '@powersync/drizzle-driver';
import { drizzleSchema } from '@/db/schema/client';
import {
  PowerSyncDatabase,
  WASQLiteOpenFactory,
  WASQLiteVFS,
  createBaseLogger,
  LogLevel,
} from '@powersync/web';
import { DrizzleAppSchema } from '@powersync/drizzle-driver';

const schema = new DrizzleAppSchema(drizzleSchema);

const logger = createBaseLogger();
logger.useDefaults();
logger.setLevel(LogLevel.DEBUG);

export const powerSyncDb = new PowerSyncDatabase({
  schema,
  database: new WASQLiteOpenFactory({
    dbFilename: 'powersync10.db',
    vfs: WASQLiteVFS.OPFSCoopSyncVFS,
    flags: {
      enableMultiTabs: typeof SharedWorker !== 'undefined',
      ssrMode: false,
    },
  }),
  flags: {
    enableMultiTabs: typeof SharedWorker !== 'undefined',
  },
});

const connector = new BackendConnector();
powerSyncDb.connect(connector);

export const drizzleDb = wrapPowerSyncWithDrizzle(powerSyncDb, {
  schema: drizzleSchema,
});

And in my connector I have this line:

clientImplementation: SyncClientImplementation = SyncClientImplementation.RUST;

Drizzle tables:

import { sqliteTable, text, integer, index, unique } from 'drizzle-orm/sqlite-core';
import { relations, sql } from 'drizzle-orm';

export const projects = sqliteTable('projects', {
  id: text('id')
    .primaryKey()
    .default(sql`uuid()`),
  userId: text('user_id').notNull(),
  name: text('name', { length: 100 }).notNull().default(''),
  status: text('status', { length: 20 }).notNull().default('new'),
  isDeleted: integer('is_deleted', { mode: 'boolean' }).notNull().default(false),
  createdAt: text('created_at')
    .notNull()
    .default(sql`datetime('now')`),
  updatedAt: text('updated_at')
    .notNull()
    .default(sql`datetime('now')`),
  completedAt: text('completed_at'),
});

export const todos = sqliteTable(
  'todos',
  {
    id: text('id')
      .primaryKey()
      .default(sql`uuid()`),
    userId: text('user_id').notNull(),
    projectId: text('project_id').references(() => projects.id, { onDelete: 'cascade' }),
    name: text('name', { length: 100 }).notNull().default(''),
    status: text('status', { length: 20 }).notNull().default('new'),
    when: text('when', { length: 20 }).notNull().default('week'),
    notes: text('notes'),
    isDeleted: integer('is_deleted', { mode: 'boolean' }).notNull().default(false),
    createdAt: text('created_at')
      .notNull()
      .default(sql`datetime('now')`),
    updatedAt: text('updated_at')
      .notNull()
      .default(sql`datetime('now')`),
    completedAt: text('completed_at'),
  },
  (table) => [index('todos_project_id_idx').on(table.projectId)],
);

export const settings = sqliteTable(
  'settings',
  {
    id: text('id')
      .primaryKey()
      .default(sql`uuid()`),
    userId: text('user_id').notNull(),
    clearCompletedAt: text('clear_completed_at'),
    createdAt: text('created_at')
      .notNull()
      .default(sql`datetime('now')`),
    updatedAt: text('updated_at')
      .notNull()
      .default(sql`datetime('now')`),
  },
  (table) => [unique('unique_settings').on(table.userId)],
);

export const projectsRelations = relations(projects, ({ many }) => ({
  todos: many(todos),
}));

export const todosRelations = relations(todos, ({ one }) => ({
  project: one(projects, {
    fields: [todos.projectId],
    references: [projects.id],
  }),
}));

export const drizzleSchema = {
  projects,
  todos,
  settings,
  projectsRelations,
  todosRelations,
};

[simolus3]

The message should not have been printed since wrapPowerSyncWithDrizzle does not use raw tables. That's a bug in our SDK.

And in my connector I have this line:

I think you would have to pass that as a second argument to connect instead of defining it in your connector, or is that what you meant?

[ivanvolti]

Thanks, yeah I mean I do it like this (please let me know if this is incorrect for web SDK):

powerSyncDb.connect(connector, {
  clientImplementation: SyncClientImplementation.RUST,
});

[SashaKryzh]

I updated powersync to 1.23.0 and don't use Rust client, but I keep seeing this warning. Am I doing something wrong?

    "@powersync/attachments": "^2.3.1",
    "@powersync/drizzle-driver": "^0.4.0",
    "@powersync/op-sqlite": "^0.7.4",
    "@powersync/react-native": "^1.23.0",

export const ATTACHMENTS_TABLE = 'attachments';

export const NoteStatuses = {
  draft: 'draft',
  uploading: 'uploading',
  transcribing: 'transcribing',
  summarizing: 'summarizing',
  generated: 'generated',
  edited: 'edited',
  rateLimited: 'rate_limited',
  failed: 'failed',
  retrying: 'retrying',
} as const;

export type NoteStatus = (typeof NoteStatuses)[keyof typeof NoteStatuses];

export const StarredStatuses = {
  unstarred: 0,
  starred: 1,
} as const;

export type Starred = (typeof StarredStatuses)[keyof typeof StarredStatuses];

export const FileStatuses = {
  uploading: 'uploading',
  uploaded: 'uploaded',
  transcribing: 'transcribing',
  transcribed: 'transcribed',
  edited: 'edited',
  rateLimited: 'rate_limited',
  failed: 'failed',
} as const;

export type FileStatus = (typeof FileStatuses)[keyof typeof FileStatuses];

export const notesTable = sqliteTable('notes', {
  id: text('id').primaryKey(),
  userId: text('user_id').notNull(),
  status: text('status').notNull().$type<NoteStatus>(),
  title: text('title').notNull(),
  summary: text('summary'),
  freeText: text('free_text'),
  starred: integer('starred').notNull().$type<Starred>(),
  noteDate: text('note_date').notNull(),
  createdAt: text('created_at').notNull(),
  updatedAt: text('updated_at').notNull(),
  deletedAt: text('deleted_at'),
});

export const tagsTable = sqliteTable('tags', {
  id: text('id').primaryKey(),
  userId: text('user_id').notNull(),
  name: text('name').notNull(),
  color: text('color').notNull(),
  createdAt: text('created_at').notNull(),
  updatedAt: text('updated_at').notNull(),
});

export const filesTable = sqliteTable('files', {
  id: text('id').primaryKey(),
  userId: text('user_id').notNull(),
  noteId: text('note_id').notNull(),
  filename: text('filename').notNull(),
  durationMs: integer('duration_ms'),
  transcript: text('transcript'),
  status: text('status').notNull().$type<FileStatus>(),
  createdAt: text('created_at').notNull(),
  updatedAt: text('updated_at').notNull(),
  deletedAt: text('deleted_at'),
});

export const noteTagsTable = sqliteTable('note_tags', {
  id: text('id').primaryKey(),
  userId: text('user_id').notNull(),
  noteId: text('note_id').notNull(),
  tagId: text('tag_id').notNull(),
  createdAt: text('created_at').notNull(),
  // TODO: remove this column?
  updatedAt: text('updated_at').notNull(),
});

export const notesRelations = relations(notesTable, ({ many }) => ({
  files: many(filesTable),
  noteTags: many(noteTagsTable),
}));

export const tagsRelations = relations(tagsTable, ({ many }) => ({
  noteTags: many(noteTagsTable),
}));

export const filesRelations = relations(filesTable, ({ one }) => ({
  note: one(notesTable, {
    fields: [filesTable.noteId],
    references: [notesTable.id],
  }),
}));

export const noteTagsRelations = relations(noteTagsTable, ({ one }) => ({
  note: one(notesTable, {
    fields: [noteTagsTable.noteId],
    references: [notesTable.id],
  }),
  tag: one(tagsTable, {
    fields: [noteTagsTable.tagId],
    references: [tagsTable.id],
  }),
}));

export const rateLimitsTable = sqliteTable('rate_limits', {
  id: text('id').primaryKey(),
  userId: text('user_id').notNull(),
  // Limits for this period
  transcriptionCountLimit: integer('transcription_count_limit').notNull().default(100),
  audioSecondsLimit: integer('audio_seconds_limit').notNull().default(3600), // 1 hour default
  // Current usage counters
  transcriptionCountUsed: integer('transcription_count_used').notNull().default(0),
  audioSecondsUsed: integer('audio_seconds_used').notNull().default(0),
  // Period tracking
  periodDurationHours: integer('period_duration_hours').notNull().default(24),
  periodStart: text('period_start').notNull(),
  createdAt: text('created_at').notNull(),
  updatedAt: text('updated_at').notNull(),
});

export const drizzleSchema = {
  notesTable,
  tagsTable,
  filesTable,
  noteTagsTable,
  notesRelations,
  tagsRelations,
  filesRelations,
  noteTagsRelations,
  rateLimitsTable,
};

export const AppSchema = new Schema({
  notes: toPowerSyncTable(notesTable, { ignoreEmptyUpdates: true }),
  tags: toPowerSyncTable(tagsTable, { ignoreEmptyUpdates: true }),
  files: toPowerSyncTable(filesTable, { ignoreEmptyUpdates: true }),
  note_tags: toPowerSyncTable(noteTagsTable, { ignoreEmptyUpdates: true }),
  rate_limits: toPowerSyncTable(rateLimitsTable, { ignoreEmptyUpdates: true }),
  [ATTACHMENTS_TABLE]: new AttachmentTable(),
});

const factory = new OPSqliteOpenFactory({
  dbFilename: 'powersync.db',
  debugMode: process.env.NODE_ENV === 'development',
});

export const powersync = new PowerSyncDatabase({
  schema: AppSchema,
  database: factory,
});

export const db = wrapPowerSyncWithDrizzle(powersync, {
  schema: drizzleSchema,
});

await powersync.init();
await this.memoAttachmentQueue.init();

await configureFts(powersync); // tried also to comment this and reinstall the app, but still see the warning.

[simolus3]

Sorry about that! You're not doing anything wrong and can ignore that warning - the fix has not been released yet but it looks like that'll happen soon.

please let me know if this is incorrect for web SDK

I think it's correct, but the warning indicates that the option wasn't picked up - I'll take a look!

[simolus3]

@ivanvolti I can't reproduce that issue with the rust client. Is the snippet you've shared the only place where you call .connect()? Are you using the shared sync worker or do you have a custom setup there?

It's somewhat concerning that you specify the rust client and we still appear to be using the JS client regardless (the "Raw tables require the Rust-based sync client" issue wouldn't happen if the implementation didn't use the Rust client).