Development

.npmrc

@@ -1 +1,2 @@
 package-import-method=clone-or-copy
+public-hoist-pattern[]=pdfjs-dist

backend/emails/helpers/index.tsx

@@ -0,0 +1,49 @@
+import { JSDOM } from 'jsdom';
+
+export const updateSourcesFromDataUrl = (passedHTML: string): string => {
+  // Parse the HTML string with JSDOM
+  const dom = new JSDOM(passedHTML);
+  const document = dom.window.document;
+
+  // Select all elements with a 'data-url' attribute within the document
+  const elementsWithDataUrl = document.querySelectorAll('[data-url]');
+
+  // Loop through each element with a 'data-url' attribute
+  for (const el of elementsWithDataUrl) {
+    const url = el.getAttribute('data-url');
+    const contentType = el.getAttribute('data-content-type');
+
+    if (!url) continue;
+
+    if (contentType === 'image') {
+      const imageElement = el.querySelector('img');
+      if (imageElement) imageElement.setAttribute('src', url);
+    }
+
+    // Add if email send library support video & audio
+    // if (contentType === 'video') {
+    //   const videoElement = el.querySelector('video');
+    //   if (videoElement) videoElement.setAttribute('src', url);
+    // }
+
+    // if (contentType === 'audio') {
+    //   const audioElement = el.querySelector('audio');
+    //   if (audioElement) audioElement.setAttribute('src', url);
+    // }
+
+    if (contentType === 'file') {
+      const fileLinkElement = document.createElement('a');
+      fileLinkElement.setAttribute('href', url);
+
+      // Set the 'download' attribute using the 'data-name' attribute or other source
+      const fileName = el.getAttribute('data-name') || 'file';
+      fileLinkElement.setAttribute('download', fileName);
+
+      // Move the original element (el) inside the <a> tag
+      el.parentNode?.replaceChild(fileLinkElement, el);
+      fileLinkElement.appendChild(el);
+    }
+  }
+
+  return document.documentElement.outerHTML;
+};

backend/emails/organization-newsletter.tsx

@@ -5,6 +5,7 @@ import { EmailContainer } from './components/container';
 import { EmailHeader } from './components/email-header';
 import { EmailReplyTo } from './components/email-reply-to';
 import { Footer } from './components/footer';
+import { updateSourcesFromDataUrl } from './helpers';
 import type { BasicTemplateType } from './types';
 
 interface Props extends BasicTemplateType {
@@ -48,7 +49,7 @@ export const organizationsNewsletter = ({ userLanguage: lng, authorEmail, conten
       >
         <Text>{subject}</Text>
         {/* biome-ignore lint/security/noDangerouslySetInnerHtml: we need send it cos blackNote return an html*/}
-        <div dangerouslySetInnerHTML={{ __html: content }} />
+        <div dangerouslySetInnerHTML={{ __html: updateSourcesFromDataUrl(content) }} />
         <Link
           style={{
             fontSize: '.75rem',

backend/package.json

@@ -29,7 +29,7 @@
     "emails:preview": "email preview ./emails"
   },
   "dependencies": {
-    "@cellajs/imado": "^0.1.3",
+    "@aws-sdk/cloudfront-signer": "^3.679.0",
     "@cellajs/permission-manager": "^0.1.0",
     "@commander-js/extra-typings": "^12.1.0",
     "@electric-sql/pglite": "^0.2.12",
@@ -63,6 +63,7 @@
     "hono": "4.6.8",
     "i18next": "^23.16.4",
     "isbot": "^5.1.17",
+    "jsdom": "^25.0.1",
     "jsonwebtoken": "^9.0.2",
     "jsx-email": "^2.1.2",
     "locales": "workspace:*",
@@ -83,6 +84,7 @@
   },
   "devDependencies": {
     "@faker-js/faker": "^9.1.0",
+    "@types/jsdom": "^21.1.7",
     "@types/jsonwebtoken": "^9.0.7",
     "@types/node": "^22.8.6",
     "@types/node-cron": "^3.0.11",

backend/src/db/db.ts

@@ -1,25 +1,33 @@
-import { drizzle as pgDrizzle } from 'drizzle-orm/node-postgres';
+import { type NodePgClient, drizzle as pgDrizzle } from 'drizzle-orm/node-postgres';
 import { drizzle as pgliteDrizzle } from 'drizzle-orm/pglite';
-import pg from 'pg';
 import { env } from '#/../env';
 
+import type { PGlite } from '@electric-sql/pglite';
 import { config } from 'config';
-import { sql } from 'drizzle-orm';
+import { type DrizzleConfig, sql } from 'drizzle-orm';
 import type { PgDatabase } from 'drizzle-orm/pg-core';
 
-export const queryClient = env.PGLITE
-  ? await (await import('@electric-sql/pglite')).PGlite.create({
-      dataDir: './.db',
-    })
-  : new pg.Pool({
-      connectionString: env.DATABASE_URL,
-      connectionTimeoutMillis: 10000,
-    });
-
-const dbConfig = {
+const dbConfig: DrizzleConfig = {
   logger: config.debug,
+  casing: 'snake_case',
 };
+
 // biome-ignore lint/suspicious/noExplicitAny: Can be two different types
-export const db: PgDatabase<any> = queryClient instanceof pg.Pool ? pgDrizzle(queryClient, dbConfig) : pgliteDrizzle(queryClient, dbConfig);
+export const db: PgDatabase<any> & {
+  $client: PGlite | NodePgClient;
+} = env.PGLITE
+  ? pgliteDrizzle({
+      connection: {
+        dataDir: './.db',
+      },
+      ...dbConfig,
+    })
+  : pgDrizzle({
+      connection: {
+        connectionString: env.DATABASE_URL,
+        connectionTimeoutMillis: 10000,
+      },
+      ...dbConfig,
+    });
 
 export const coalesce = <T>(column: T, value: number) => sql`COALESCE(${column}, ${value})`.mapWith(Number);

backend/src/db/schema/attachments.ts

@@ -1,32 +1,35 @@
+import { getTableColumns } from 'drizzle-orm';
 import { pgTable, timestamp, varchar } from 'drizzle-orm/pg-core';
 import { nanoid } from '#/utils/nanoid';
 import { organizationsTable } from './organizations';
 import { usersTable } from './users';
 
 export const attachmentsTable = pgTable('attachments', {
-  id: varchar('id').primaryKey().$defaultFn(nanoid),
-  name: varchar('name').notNull().default('attachment'),
-  filename: varchar('filename').notNull(),
-  contentType: varchar('content_type').notNull(),
-  size: varchar('size').notNull(),
-  entity: varchar('entity', { enum: ['attachment'] })
+  id: varchar().primaryKey().$defaultFn(nanoid),
+  name: varchar().notNull().default('attachment'),
+  filename: varchar().notNull(),
+  contentType: varchar().notNull(),
+  size: varchar().notNull(),
+  entity: varchar({ enum: ['attachment'] })
     .notNull()
     .default('attachment'),
-  url: varchar('url').notNull(),
-  createdAt: timestamp('created_at').defaultNow().notNull(),
-  createdBy: varchar('created_by').references(() => usersTable.id, {
+  url: varchar().notNull(),
+  createdAt: timestamp().defaultNow().notNull(),
+  createdBy: varchar().references(() => usersTable.id, {
     onDelete: 'set null',
   }),
-  modifiedAt: timestamp('modified_at'),
-  modifiedBy: varchar('modified_by').references(() => usersTable.id, {
+  modifiedAt: timestamp(),
+  modifiedBy: varchar().references(() => usersTable.id, {
     onDelete: 'set null',
   }),
-  organizationId: varchar('organization_id')
+  organizationId: varchar()
     .notNull()
     .references(() => organizationsTable.id, {
       onDelete: 'cascade',
     }),
 });
 
+export const attachmentsTableColumns = getTableColumns(attachmentsTable);
+
 export type AttachmentModel = typeof attachmentsTable.$inferSelect;
 export type InsertAttachmentModel = typeof attachmentsTable.$inferInsert;

backend/src/db/schema/memberships.ts

@@ -7,20 +7,20 @@ import { organizationsTable } from './organizations';
 const roleEnum = config.rolesByType.entityRoles;
 
 export const membershipsTable = pgTable('memberships', {
-  id: varchar('id').primaryKey().$defaultFn(nanoid),
-  type: varchar('type', { enum: config.contextEntityTypes }).notNull(),
-  userId: varchar('user_id')
+  id: varchar().primaryKey().$defaultFn(nanoid),
+  type: varchar({ enum: config.contextEntityTypes }).notNull(),
+  userId: varchar()
     .notNull()
     .references(() => usersTable.id, { onDelete: 'cascade' }),
-  role: varchar('role', { enum: roleEnum }).notNull().default('member'),
-  createdAt: timestamp('created_at').defaultNow().notNull(),
-  createdBy: varchar('created_by').references(() => usersTable.id, { onDelete: 'set null' }),
-  modifiedAt: timestamp('modified_at'),
-  modifiedBy: varchar('modified_by').references(() => usersTable.id, { onDelete: 'set null' }),
-  archived: boolean('archived').default(false).notNull(),
-  muted: boolean('muted').default(false).notNull(),
-  order: doublePrecision('sort_order').notNull(),
-  organizationId: varchar('organization_id')
+  role: varchar({ enum: roleEnum }).notNull().default('member'),
+  createdAt: timestamp().defaultNow().notNull(),
+  createdBy: varchar().references(() => usersTable.id, { onDelete: 'set null' }),
+  modifiedAt: timestamp(),
+  modifiedBy: varchar().references(() => usersTable.id, { onDelete: 'set null' }),
+  archived: boolean().default(false).notNull(),
+  muted: boolean().default(false).notNull(),
+  order: doublePrecision().notNull(),
+  organizationId: varchar()
     .notNull()
     .references(() => organizationsTable.id, { onDelete: 'cascade' }),
 });

backend/src/db/schema/oauth-accounts.ts

@@ -8,12 +8,12 @@ export const supportedOauthProviders = ['github', 'google', 'microsoft'] as cons
 export const oauthAccountsTable = pgTable(
   'oauth_accounts',
   {
-    providerId: varchar('provider_id', { enum: supportedOauthProviders }).notNull(),
-    providerUserId: varchar('provider_user_id').notNull(),
-    userId: varchar('user_id')
+    providerId: varchar({ enum: supportedOauthProviders }).notNull(),
+    providerUserId: varchar().notNull(),
+    userId: varchar()
       .notNull()
       .references(() => usersTable.id, { onDelete: 'cascade' }),
-    createdAt: timestamp('created_at').defaultNow().notNull(),
+    createdAt: timestamp().defaultNow().notNull(),
   },
   (table) => {
     return {

backend/src/db/schema/organizations.ts

@@ -10,31 +10,31 @@ const languages = config.languages.map((lang) => lang.value) as [string, ...stri
 export const organizationsTable = pgTable(
   'organizations',
   {
-    id: varchar('id').primaryKey().$defaultFn(nanoid),
-    entity: varchar('entity', { enum: ['organization'] })
+    id: varchar().primaryKey().$defaultFn(nanoid),
+    entity: varchar({ enum: ['organization'] })
       .notNull()
       .default('organization'),
-    name: varchar('name').notNull(),
-    shortName: varchar('short_name'),
-    slug: varchar('slug').unique().notNull(),
-    country: varchar('country'),
-    timezone: varchar('timezone'),
-    defaultLanguage: varchar('default_language', { enum: languages }).notNull().default(config.defaultLanguage),
-    languages: json('languages').$type<Language[]>().notNull().default([config.defaultLanguage]),
-    notificationEmail: varchar('notification_email'),
-    emailDomains: json('email_domains').$type<string[]>().notNull().default([]),
-    color: varchar('color'),
-    thumbnailUrl: varchar('thumbnail_url'),
-    bannerUrl: varchar('banner_url'),
-    logoUrl: varchar('logo_url'),
-    websiteUrl: varchar('website_url'),
-    welcomeText: varchar('welcome_text'),
-    authStrategies: json('auth_strategies').$type<string[]>().notNull().default([]),
-    chatSupport: boolean('chat_support').notNull().default(false),
-    createdAt: timestamp('created_at').defaultNow().notNull(),
-    createdBy: varchar('created_by').references(() => usersTable.id, { onDelete: 'set null' }),
-    modifiedAt: timestamp('modified_at'),
-    modifiedBy: varchar('modified_by').references(() => usersTable.id, { onDelete: 'set null' }),
+    name: varchar().notNull(),
+    shortName: varchar(),
+    slug: varchar().unique().notNull(),
+    country: varchar(),
+    timezone: varchar(),
+    defaultLanguage: varchar({ enum: languages }).notNull().default(config.defaultLanguage),
+    languages: json().$type<Language[]>().notNull().default([config.defaultLanguage]),
+    notificationEmail: varchar(),
+    emailDomains: json().$type<string[]>().notNull().default([]),
+    color: varchar(),
+    thumbnailUrl: varchar(),
+    bannerUrl: varchar(),
+    logoUrl: varchar(),
+    websiteUrl: varchar(),
+    welcomeText: varchar(),
+    authStrategies: json().$type<string[]>().notNull().default([]),
+    chatSupport: boolean().notNull().default(false),
+    createdAt: timestamp().defaultNow().notNull(),
+    createdBy: varchar().references(() => usersTable.id, { onDelete: 'set null' }),
+    modifiedAt: timestamp(),
+    modifiedBy: varchar().references(() => usersTable.id, { onDelete: 'set null' }),
   },
   (table) => {
     return {

backend/src/db/schema/passkeys.ts

@@ -3,13 +3,13 @@ import { usersTable } from '#/db/schema/users';
 import { nanoid } from '#/utils/nanoid';
 
 export const passkeysTable = pgTable('passkeys', {
-  id: varchar('id').primaryKey().$defaultFn(nanoid),
-  userEmail: varchar('user_email')
+  id: varchar().primaryKey().$defaultFn(nanoid),
+  userEmail: varchar()
     .notNull()
     .references(() => usersTable.email, { onDelete: 'cascade' }),
-  credentialId: varchar('credential_id').notNull(),
-  publicKey: varchar('public_key').notNull(),
-  createdAt: timestamp('created_at').defaultNow().notNull(),
+  credentialId: varchar().notNull(),
+  publicKey: varchar().notNull(),
+  createdAt: timestamp().defaultNow().notNull(),
 });
 
 export type PasskeyModel = typeof passkeysTable.$inferSelect;

backend/src/db/schema/requests.ts

@@ -7,11 +7,11 @@ export type RequestType = (typeof requestTypeEnum)[number];
 export const requestsTable = pgTable(
   'requests',
   {
-    id: varchar('id').primaryKey().$defaultFn(nanoid),
-    message: varchar('message'),
-    email: varchar('email').notNull(),
-    type: varchar('type', { enum: requestTypeEnum }).notNull(),
-    createdAt: timestamp('created_at').defaultNow().notNull(),
+    id: varchar().primaryKey().$defaultFn(nanoid),
+    message: varchar(),
+    email: varchar().notNull(),
+    type: varchar({ enum: requestTypeEnum }).notNull(),
+    createdAt: timestamp().defaultNow().notNull(),
   },
   (table) => {
     return {

backend/src/db/schema/sessions.ts

@@ -4,27 +4,27 @@ import { usersTable } from '#/db/schema/users';
 export const sessionsTable = pgTable(
   'sessions',
   {
-    id: varchar('id').primaryKey(),
-    userId: varchar('user_id')
+    id: varchar().primaryKey(),
+    userId: varchar()
       .notNull()
       .references(() => usersTable.id, { onDelete: 'cascade' }),
-    deviceName: varchar('device_name'),
-    deviceType: varchar('device_type', { enum: ['desktop', 'mobile'] })
+    deviceName: varchar(),
+    deviceType: varchar({ enum: ['desktop', 'mobile'] })
       .notNull()
       .default('desktop'),
-    deviceOs: varchar('device_os'),
-    browser: varchar('browser'),
-    authStrategy: varchar('auth_strategy', {
+    deviceOs: varchar(),
+    browser: varchar(),
+    authStrategy: varchar({
       enum: ['github', 'google', 'microsoft', 'password', 'passkey'],
     }),
-    type: varchar('type', {
+    type: varchar({
       enum: ['regular', 'impersonation'],
     })
       .notNull()
       .default('regular'),
-    createdAt: timestamp('created_at').defaultNow().notNull(),
-    expiresAt: timestamp('expires_at', { withTimezone: true, mode: 'date' }).notNull(),
-    adminUserId: varchar('admin_user_id').references(() => usersTable.id, { onDelete: 'cascade' }),
+    createdAt: timestamp().defaultNow().notNull(),
+    expiresAt: timestamp({ withTimezone: true, mode: 'date' }).notNull(),
+    adminUserId: varchar().references(() => usersTable.id, { onDelete: 'cascade' }),
   },
   (table) => {
     return {

backend/src/db/schema/tokens.ts

@@ -7,14 +7,14 @@ const tokenTypeEnum = ['email_verification', 'password_reset', 'system_invitatio
 const roleEnum = config.rolesByType.allRoles;
 
 export const tokensTable = pgTable('tokens', {
-  id: varchar('id').primaryKey(),
-  type: varchar('type', { enum: tokenTypeEnum }).notNull(),
-  email: varchar('email'),
-  role: varchar('role', { enum: roleEnum }),
-  userId: varchar('user_id').references(() => usersTable.id, { onDelete: 'cascade' }),
-  organizationId: varchar('organization_id').references(() => organizationsTable.id, { onDelete: 'cascade' }),
-  createdAt: timestamp('created_at').defaultNow().notNull(),
-  expiresAt: timestamp('expires_at', { withTimezone: true, mode: 'date' }).notNull(),
+  id: varchar().primaryKey(),
+  type: varchar({ enum: tokenTypeEnum }).notNull(),
+  email: varchar(),
+  role: varchar({ enum: roleEnum }),
+  userId: varchar().references(() => usersTable.id, { onDelete: 'cascade' }),
+  organizationId: varchar().references(() => organizationsTable.id, { onDelete: 'cascade' }),
+  createdAt: timestamp().defaultNow().notNull(),
+  expiresAt: timestamp({ withTimezone: true, mode: 'date' }).notNull(),
 });
 
 export type TokenModel = typeof tokensTable.$inferSelect;