refactor(server)*: tsconfigs (#2689)

* refactor(server): tsconfigs

* chore: dummy commit

* fix: start.sh

* chore: restore original entry scripts

server/src/infra/entities/album.entity.ts

@@ -0,0 +1,52 @@
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  JoinTable,
+  ManyToMany,
+  ManyToOne,
+  OneToMany,
+  PrimaryGeneratedColumn,
+  UpdateDateColumn,
+} from 'typeorm';
+import { SharedLinkEntity } from './shared-link.entity';
+import { AssetEntity } from './asset.entity';
+import { UserEntity } from './user.entity';
+
+@Entity('albums')
+export class AlbumEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id!: string;
+
+  @ManyToOne(() => UserEntity, { onDelete: 'CASCADE', onUpdate: 'CASCADE', nullable: false })
+  owner!: UserEntity;
+
+  @Column()
+  ownerId!: string;
+
+  @Column({ default: 'Untitled Album' })
+  albumName!: string;
+
+  @CreateDateColumn({ type: 'timestamptz' })
+  createdAt!: Date;
+
+  @UpdateDateColumn({ type: 'timestamptz' })
+  updatedAt!: Date;
+
+  @ManyToOne(() => AssetEntity, { nullable: true, onDelete: 'SET NULL', onUpdate: 'CASCADE' })
+  albumThumbnailAsset!: AssetEntity | null;
+
+  @Column({ comment: 'Asset ID to be used as thumbnail', nullable: true })
+  albumThumbnailAssetId!: string | null;
+
+  @ManyToMany(() => UserEntity)
+  @JoinTable()
+  sharedUsers!: UserEntity[];
+
+  @ManyToMany(() => AssetEntity, (asset) => asset.albums)
+  @JoinTable()
+  assets!: AssetEntity[];
+
+  @OneToMany(() => SharedLinkEntity, (link) => link.album)
+  sharedLinks!: SharedLinkEntity[];
+}

server/src/infra/entities/api-key.entity.ts

@@ -0,0 +1,26 @@
+import { Column, CreateDateColumn, Entity, ManyToOne, PrimaryGeneratedColumn, UpdateDateColumn } from 'typeorm';
+import { UserEntity } from './user.entity';
+
+@Entity('api_keys')
+export class APIKeyEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id!: string;
+
+  @Column()
+  name!: string;
+
+  @Column({ select: false })
+  key?: string;
+
+  @ManyToOne(() => UserEntity, { onUpdate: 'CASCADE', onDelete: 'CASCADE' })
+  user?: UserEntity;
+
+  @Column()
+  userId!: string;
+
+  @CreateDateColumn({ type: 'timestamptz' })
+  createdAt!: Date;
+
+  @UpdateDateColumn({ type: 'timestamptz' })
+  updatedAt!: Date;
+}

server/src/infra/entities/asset-face.entity.ts

@@ -0,0 +1,25 @@
+import { Column, Entity, ManyToOne, PrimaryColumn } from 'typeorm';
+import { AssetEntity } from './asset.entity';
+import { PersonEntity } from './person.entity';
+
+@Entity('asset_faces')
+export class AssetFaceEntity {
+  @PrimaryColumn()
+  assetId!: string;
+
+  @PrimaryColumn()
+  personId!: string;
+
+  @Column({
+    type: 'float4',
+    array: true,
+    nullable: true,
+  })
+  embedding!: number[] | null;
+
+  @ManyToOne(() => AssetEntity, (asset) => asset.faces, { onDelete: 'CASCADE', onUpdate: 'CASCADE' })
+  asset!: AssetEntity;
+
+  @ManyToOne(() => PersonEntity, (person) => person.faces, { onDelete: 'CASCADE', onUpdate: 'CASCADE' })
+  person!: PersonEntity;
+}

server/src/infra/entities/asset.entity.ts

@@ -0,0 +1,127 @@
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  JoinColumn,
+  JoinTable,
+  ManyToMany,
+  ManyToOne,
+  OneToMany,
+  OneToOne,
+  PrimaryGeneratedColumn,
+  Unique,
+  UpdateDateColumn,
+} from 'typeorm';
+import { AlbumEntity } from './album.entity';
+import { AssetFaceEntity } from './asset-face.entity';
+import { ExifEntity } from './exif.entity';
+import { SharedLinkEntity } from './shared-link.entity';
+import { SmartInfoEntity } from './smart-info.entity';
+import { TagEntity } from './tag.entity';
+import { UserEntity } from './user.entity';
+
+@Entity('assets')
+@Unique('UQ_userid_checksum', ['owner', 'checksum'])
+export class AssetEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id!: string;
+
+  @Column()
+  deviceAssetId!: string;
+
+  @ManyToOne(() => UserEntity, { onDelete: 'CASCADE', onUpdate: 'CASCADE', nullable: false })
+  owner!: UserEntity;
+
+  @Column()
+  ownerId!: string;
+
+  @Column()
+  deviceId!: string;
+
+  @Column()
+  type!: AssetType;
+
+  @Column()
+  originalPath!: string;
+
+  @Column({ type: 'varchar', nullable: true })
+  resizePath!: string | null;
+
+  @Column({ type: 'varchar', nullable: true, default: '' })
+  webpPath!: string | null;
+
+  @Column({ type: 'varchar', nullable: true, default: '' })
+  encodedVideoPath!: string | null;
+
+  @CreateDateColumn({ type: 'timestamptz' })
+  createdAt!: Date;
+
+  @UpdateDateColumn({ type: 'timestamptz' })
+  updatedAt!: Date;
+
+  @Column({ type: 'timestamptz' })
+  fileCreatedAt!: Date;
+
+  @Column({ type: 'timestamptz' })
+  fileModifiedAt!: Date;
+
+  @Column({ type: 'boolean', default: false })
+  isFavorite!: boolean;
+
+  @Column({ type: 'boolean', default: false })
+  isArchived!: boolean;
+
+  @Column({ type: 'varchar', nullable: true })
+  mimeType!: string | null;
+
+  @Column({ type: 'bytea' })
+  @Index()
+  checksum!: Buffer; // sha1 checksum
+
+  @Column({ type: 'varchar', nullable: true })
+  duration!: string | null;
+
+  @Column({ type: 'boolean', default: true })
+  isVisible!: boolean;
+
+  @OneToOne(() => AssetEntity, { nullable: true, onUpdate: 'CASCADE', onDelete: 'SET NULL' })
+  @JoinColumn()
+  livePhotoVideo!: AssetEntity | null;
+
+  @Column({ nullable: true })
+  livePhotoVideoId!: string | null;
+
+  @Column({ type: 'varchar' })
+  originalFileName!: string;
+
+  @Column({ type: 'varchar', nullable: true })
+  sidecarPath!: string | null;
+
+  @OneToOne(() => ExifEntity, (exifEntity) => exifEntity.asset)
+  exifInfo?: ExifEntity;
+
+  @OneToOne(() => SmartInfoEntity, (smartInfoEntity) => smartInfoEntity.asset)
+  smartInfo?: SmartInfoEntity;
+
+  @ManyToMany(() => TagEntity, (tag) => tag.assets, { cascade: true })
+  @JoinTable({ name: 'tag_asset' })
+  tags!: TagEntity[];
+
+  @ManyToMany(() => SharedLinkEntity, (link) => link.assets, { cascade: true })
+  @JoinTable({ name: 'shared_link__asset' })
+  sharedLinks!: SharedLinkEntity[];
+
+  @ManyToMany(() => AlbumEntity, (album) => album.assets, { onDelete: 'CASCADE', onUpdate: 'CASCADE' })
+  albums?: AlbumEntity[];
+
+  @OneToMany(() => AssetFaceEntity, (assetFace) => assetFace.asset)
+  faces!: AssetFaceEntity[];
+}
+
+export enum AssetType {
+  IMAGE = 'IMAGE',
+  VIDEO = 'VIDEO',
+  AUDIO = 'AUDIO',
+  OTHER = 'OTHER',
+}

server/src/infra/entities/exif.entity.ts

@@ -0,0 +1,99 @@
+import { Index, JoinColumn, OneToOne, PrimaryColumn } from 'typeorm';
+import { Column } from 'typeorm/decorator/columns/Column';
+import { Entity } from 'typeorm/decorator/entity/Entity';
+import { AssetEntity } from './asset.entity';
+
+@Entity('exif')
+export class ExifEntity {
+  @OneToOne(() => AssetEntity, { onDelete: 'CASCADE', nullable: true })
+  @JoinColumn()
+  asset?: AssetEntity;
+
+  @PrimaryColumn()
+  assetId!: string;
+
+  /* General info */
+  @Column({ type: 'text', default: '' })
+  description!: string; // or caption
+
+  @Column({ type: 'integer', nullable: true })
+  exifImageWidth!: number | null;
+
+  @Column({ type: 'integer', nullable: true })
+  exifImageHeight!: number | null;
+
+  @Column({ type: 'bigint', nullable: true })
+  fileSizeInByte!: number | null;
+
+  @Column({ type: 'varchar', nullable: true })
+  orientation!: string | null;
+
+  @Column({ type: 'timestamptz', nullable: true })
+  dateTimeOriginal!: Date | null;
+
+  @Column({ type: 'timestamptz', nullable: true })
+  modifyDate!: Date | null;
+
+  @Column({ type: 'varchar', nullable: true })
+  timeZone!: string | null;
+
+  @Column({ type: 'float', nullable: true })
+  latitude!: number | null;
+
+  @Column({ type: 'float', nullable: true })
+  longitude!: number | null;
+
+  @Column({ type: 'varchar', nullable: true })
+  city!: string | null;
+
+  @Index('IDX_live_photo_cid')
+  @Column({ type: 'varchar', nullable: true })
+  livePhotoCID!: string | null;
+
+  @Column({ type: 'varchar', nullable: true })
+  state!: string | null;
+
+  @Column({ type: 'varchar', nullable: true })
+  country!: string | null;
+
+  /* Image info */
+  @Column({ type: 'varchar', nullable: true })
+  make!: string | null;
+
+  @Column({ type: 'varchar', nullable: true })
+  model!: string | null;
+
+  @Column({ type: 'varchar', nullable: true })
+  lensModel!: string | null;
+
+  @Column({ type: 'float8', nullable: true })
+  fNumber!: number | null;
+
+  @Column({ type: 'float8', nullable: true })
+  focalLength!: number | null;
+
+  @Column({ type: 'integer', nullable: true })
+  iso!: number | null;
+
+  @Column({ type: 'varchar', nullable: true })
+  exposureTime!: string | null;
+
+  /* Video info */
+  @Column({ type: 'float8', nullable: true })
+  fps?: number | null;
+
+  @Index('exif_text_searchable', { synchronize: false })
+  @Column({
+    type: 'tsvector',
+    generatedType: 'STORED',
+    asExpression: `TO_TSVECTOR('english',
+                         COALESCE(make, '') || ' ' ||
+                         COALESCE(model, '') || ' ' ||
+                         COALESCE(orientation, '') || ' ' ||
+                         COALESCE("lensModel", '') || ' ' ||
+                         COALESCE("city", '') || ' ' ||
+                         COALESCE("state", '') || ' ' ||
+                         COALESCE("country", ''))`,
+  })
+  exifTextSearchableColumn!: string;
+}

server/src/infra/entities/index.ts

@@ -0,0 +1,41 @@
+import { AlbumEntity } from './album.entity';
+import { APIKeyEntity } from './api-key.entity';
+import { AssetFaceEntity } from './asset-face.entity';
+import { AssetEntity } from './asset.entity';
+import { PartnerEntity } from './partner.entity';
+import { PersonEntity } from './person.entity';
+import { SharedLinkEntity } from './shared-link.entity';
+import { SmartInfoEntity } from './smart-info.entity';
+import { SystemConfigEntity } from './system-config.entity';
+import { TagEntity } from './tag.entity';
+import { UserTokenEntity } from './user-token.entity';
+import { UserEntity } from './user.entity';
+
+export * from './album.entity';
+export * from './api-key.entity';
+export * from './asset-face.entity';
+export * from './asset.entity';
+export * from './exif.entity';
+export * from './partner.entity';
+export * from './person.entity';
+export * from './shared-link.entity';
+export * from './smart-info.entity';
+export * from './system-config.entity';
+export * from './tag.entity';
+export * from './user-token.entity';
+export * from './user.entity';
+
+export const databaseEntities = [
+  AlbumEntity,
+  APIKeyEntity,
+  AssetEntity,
+  AssetFaceEntity,
+  PartnerEntity,
+  PersonEntity,
+  SharedLinkEntity,
+  SmartInfoEntity,
+  SystemConfigEntity,
+  TagEntity,
+  UserEntity,
+  UserTokenEntity,
+];

server/src/infra/entities/partner.entity.ts

@@ -0,0 +1,26 @@
+import { CreateDateColumn, Entity, ManyToOne, PrimaryColumn, JoinColumn, UpdateDateColumn } from 'typeorm';
+
+import { UserEntity } from './user.entity';
+
+@Entity('partners')
+export class PartnerEntity {
+  @PrimaryColumn('uuid')
+  sharedById!: string;
+
+  @PrimaryColumn('uuid')
+  sharedWithId!: string;
+
+  @ManyToOne(() => UserEntity, { onDelete: 'CASCADE', eager: true })
+  @JoinColumn({ name: 'sharedById' })
+  sharedBy!: UserEntity;
+
+  @ManyToOne(() => UserEntity, { onDelete: 'CASCADE', eager: true })
+  @JoinColumn({ name: 'sharedWithId' })
+  sharedWith!: UserEntity;
+
+  @CreateDateColumn({ type: 'timestamptz' })
+  createdAt!: Date;
+
+  @UpdateDateColumn({ type: 'timestamptz' })
+  updatedAt!: Date;
+}

server/src/infra/entities/person.entity.ts

@@ -0,0 +1,38 @@
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  ManyToOne,
+  OneToMany,
+  PrimaryGeneratedColumn,
+  UpdateDateColumn,
+} from 'typeorm';
+import { AssetFaceEntity } from './asset-face.entity';
+import { UserEntity } from './user.entity';
+
+@Entity('person')
+export class PersonEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id!: string;
+
+  @CreateDateColumn({ type: 'timestamptz' })
+  createdAt!: Date;
+
+  @UpdateDateColumn({ type: 'timestamptz' })
+  updatedAt!: Date;
+
+  @Column()
+  ownerId!: string;
+
+  @ManyToOne(() => UserEntity, { onDelete: 'CASCADE', onUpdate: 'CASCADE', nullable: false })
+  owner!: UserEntity;
+
+  @Column({ default: '' })
+  name!: string;
+
+  @Column({ default: '' })
+  thumbnailPath!: string;
+
+  @OneToMany(() => AssetFaceEntity, (assetFace) => assetFace.person)
+  faces!: AssetFaceEntity[];
+}

server/src/infra/entities/shared-link.entity.ts

@@ -0,0 +1,68 @@
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  ManyToMany,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+  Unique,
+} from 'typeorm';
+import { AlbumEntity } from './album.entity';
+import { AssetEntity } from './asset.entity';
+import { UserEntity } from './user.entity';
+
+@Entity('shared_links')
+@Unique('UQ_sharedlink_key', ['key'])
+export class SharedLinkEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id!: string;
+
+  @Column({ nullable: true })
+  description?: string;
+
+  @Column()
+  userId!: string;
+
+  @ManyToOne(() => UserEntity)
+  user!: UserEntity;
+
+  @Index('IDX_sharedlink_key')
+  @Column({ type: 'bytea' })
+  key!: Buffer; // use to access the inidividual asset
+
+  @Column()
+  type!: SharedLinkType;
+
+  @CreateDateColumn({ type: 'timestamptz' })
+  createdAt!: Date;
+
+  @Column({ type: 'timestamptz', nullable: true })
+  expiresAt!: Date | null;
+
+  @Column({ type: 'boolean', default: false })
+  allowUpload!: boolean;
+
+  @Column({ type: 'boolean', default: true })
+  allowDownload!: boolean;
+
+  @Column({ type: 'boolean', default: true })
+  showExif!: boolean;
+
+  @ManyToMany(() => AssetEntity, (asset) => asset.sharedLinks)
+  assets!: AssetEntity[];
+
+  @Index('IDX_sharedlink_albumId')
+  @ManyToOne(() => AlbumEntity, (album) => album.sharedLinks, { onDelete: 'CASCADE', onUpdate: 'CASCADE' })
+  album?: AlbumEntity;
+}
+
+export enum SharedLinkType {
+  ALBUM = 'ALBUM',
+
+  /**
+   * Individual asset
+   * or group of assets that are not in an album
+   */
+  INDIVIDUAL = 'INDIVIDUAL',
+}

server/src/infra/entities/smart-info.entity.ts

@@ -0,0 +1,25 @@
+import { Column, Entity, JoinColumn, OneToOne, PrimaryColumn } from 'typeorm';
+import { AssetEntity } from './asset.entity';
+
+@Entity('smart_info')
+export class SmartInfoEntity {
+  @OneToOne(() => AssetEntity, { onDelete: 'CASCADE', nullable: true })
+  @JoinColumn({ name: 'assetId', referencedColumnName: 'id' })
+  asset?: AssetEntity;
+
+  @PrimaryColumn()
+  assetId!: string;
+
+  @Column({ type: 'text', array: true, nullable: true })
+  tags!: string[] | null;
+
+  @Column({ type: 'text', array: true, nullable: true })
+  objects!: string[] | null;
+
+  @Column({
+    type: 'float4',
+    array: true,
+    nullable: true,
+  })
+  clipEmbedding!: number[] | null;
+}

server/src/infra/entities/system-config.entity.ts

@@ -0,0 +1,92 @@
+import { Column, Entity, PrimaryColumn } from 'typeorm';
+import { QueueName } from '@app/domain/job/job.constants';
+
+@Entity('system_config')
+export class SystemConfigEntity<T = SystemConfigValue> {
+  @PrimaryColumn()
+  key!: SystemConfigKey;
+
+  @Column({ type: 'varchar', nullable: true, transformer: { to: JSON.stringify, from: JSON.parse } })
+  value!: T;
+}
+
+export type SystemConfigValue = string | number | boolean;
+
+// dot notation matches path in `SystemConfig`
+export enum SystemConfigKey {
+  FFMPEG_CRF = 'ffmpeg.crf',
+  FFMPEG_THREADS = 'ffmpeg.threads',
+  FFMPEG_PRESET = 'ffmpeg.preset',
+  FFMPEG_TARGET_VIDEO_CODEC = 'ffmpeg.targetVideoCodec',
+  FFMPEG_TARGET_AUDIO_CODEC = 'ffmpeg.targetAudioCodec',
+  FFMPEG_TARGET_RESOLUTION = 'ffmpeg.targetResolution',
+  FFMPEG_MAX_BITRATE = 'ffmpeg.maxBitrate',
+  FFMPEG_TWO_PASS = 'ffmpeg.twoPass',
+  FFMPEG_TRANSCODE = 'ffmpeg.transcode',
+
+  JOB_THUMBNAIL_GENERATION_CONCURRENCY = 'job.thumbnailGeneration.concurrency',
+  JOB_METADATA_EXTRACTION_CONCURRENCY = 'job.metadataExtraction.concurrency',
+  JOB_VIDEO_CONVERSION_CONCURRENCY = 'job.videoConversion.concurrency',
+  JOB_OBJECT_TAGGING_CONCURRENCY = 'job.objectTagging.concurrency',
+  JOB_RECOGNIZE_FACES_CONCURRENCY = 'job.recognizeFaces.concurrency',
+  JOB_CLIP_ENCODING_CONCURRENCY = 'job.clipEncoding.concurrency',
+  JOB_BACKGROUND_TASK_CONCURRENCY = 'job.backgroundTask.concurrency',
+  JOB_STORAGE_TEMPLATE_MIGRATION_CONCURRENCY = 'job.storageTemplateMigration.concurrency',
+  JOB_SEARCH_CONCURRENCY = 'job.search.concurrency',
+  JOB_SIDECAR_CONCURRENCY = 'job.sidecar.concurrency',
+
+  OAUTH_ENABLED = 'oauth.enabled',
+  OAUTH_ISSUER_URL = 'oauth.issuerUrl',
+  OAUTH_CLIENT_ID = 'oauth.clientId',
+  OAUTH_CLIENT_SECRET = 'oauth.clientSecret',
+  OAUTH_SCOPE = 'oauth.scope',
+  OAUTH_AUTO_LAUNCH = 'oauth.autoLaunch',
+  OAUTH_BUTTON_TEXT = 'oauth.buttonText',
+  OAUTH_AUTO_REGISTER = 'oauth.autoRegister',
+  OAUTH_MOBILE_OVERRIDE_ENABLED = 'oauth.mobileOverrideEnabled',
+  OAUTH_MOBILE_REDIRECT_URI = 'oauth.mobileRedirectUri',
+
+  PASSWORD_LOGIN_ENABLED = 'passwordLogin.enabled',
+
+  STORAGE_TEMPLATE = 'storageTemplate.template',
+}
+
+export enum TranscodePreset {
+  ALL = 'all',
+  OPTIMAL = 'optimal',
+  REQUIRED = 'required',
+  DISABLED = 'disabled',
+}
+
+export interface SystemConfig {
+  ffmpeg: {
+    crf: number;
+    threads: number;
+    preset: string;
+    targetVideoCodec: string;
+    targetAudioCodec: string;
+    targetResolution: string;
+    maxBitrate: string;
+    twoPass: boolean;
+    transcode: TranscodePreset;
+  };
+  job: Record<QueueName, { concurrency: number }>;
+  oauth: {
+    enabled: boolean;
+    issuerUrl: string;
+    clientId: string;
+    clientSecret: string;
+    scope: string;
+    buttonText: string;
+    autoRegister: boolean;
+    autoLaunch: boolean;
+    mobileOverrideEnabled: boolean;
+    mobileRedirectUri: string;
+  };
+  passwordLogin: {
+    enabled: boolean;
+  };
+  storageTemplate: {
+    template: string;
+  };
+}

server/src/infra/entities/tag.entity.ts

@@ -0,0 +1,45 @@
+import { Column, Entity, ManyToMany, ManyToOne, PrimaryGeneratedColumn, Unique } from 'typeorm';
+import { AssetEntity } from './asset.entity';
+import { UserEntity } from './user.entity';
+
+@Entity('tags')
+@Unique('UQ_tag_name_userId', ['name', 'userId'])
+export class TagEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id!: string;
+
+  @Column()
+  type!: TagType;
+
+  @Column()
+  name!: string;
+
+  @ManyToOne(() => UserEntity, (user) => user.tags)
+  user!: UserEntity;
+
+  @Column()
+  userId!: string;
+
+  @Column({ type: 'uuid', comment: 'The new renamed tagId', nullable: true })
+  renameTagId!: string | null;
+
+  @ManyToMany(() => AssetEntity, (asset) => asset.tags)
+  assets!: AssetEntity[];
+}
+
+export enum TagType {
+  /**
+   * Tag that is detected by the ML model for object detection will use this type
+   */
+  OBJECT = 'OBJECT',
+
+  /**
+   * Face that is detected by the ML model for facial detection (TBD/NOT YET IMPLEMENTED) will use this type
+   */
+  FACE = 'FACE',
+
+  /**
+   * Tag that is created by the user will use this type
+   */
+  CUSTOM = 'CUSTOM',
+}

server/src/infra/entities/user-token.entity.ts

@@ -0,0 +1,29 @@
+import { Column, CreateDateColumn, Entity, ManyToOne, PrimaryGeneratedColumn, UpdateDateColumn } from 'typeorm';
+import { UserEntity } from './user.entity';
+
+@Entity('user_token')
+export class UserTokenEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id!: string;
+
+  @Column({ select: false })
+  token!: string;
+
+  @Column()
+  userId!: string;
+
+  @ManyToOne(() => UserEntity, { onUpdate: 'CASCADE', onDelete: 'CASCADE' })
+  user!: UserEntity;
+
+  @CreateDateColumn({ type: 'timestamptz' })
+  createdAt!: Date;
+
+  @UpdateDateColumn({ type: 'timestamptz' })
+  updatedAt!: Date;
+
+  @Column({ default: '' })
+  deviceType!: string;
+
+  @Column({ default: '' })
+  deviceOS!: string;
+}

server/src/infra/entities/user.entity.ts

@@ -0,0 +1,59 @@
+import {
+  Column,
+  CreateDateColumn,
+  DeleteDateColumn,
+  Entity,
+  OneToMany,
+  PrimaryGeneratedColumn,
+  UpdateDateColumn,
+} from 'typeorm';
+import { AssetEntity } from './asset.entity';
+import { TagEntity } from './tag.entity';
+
+@Entity('users')
+export class UserEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id!: string;
+
+  @Column({ default: '' })
+  firstName!: string;
+
+  @Column({ default: '' })
+  lastName!: string;
+
+  @Column({ default: false })
+  isAdmin!: boolean;
+
+  @Column({ unique: true })
+  email!: string;
+
+  @Column({ type: 'varchar', unique: true, default: null })
+  storageLabel!: string | null;
+
+  @Column({ default: '', select: false })
+  password?: string;
+
+  @Column({ default: '' })
+  oauthId!: string;
+
+  @Column({ default: '' })
+  profileImagePath!: string;
+
+  @Column({ default: true })
+  shouldChangePassword!: boolean;
+
+  @CreateDateColumn({ type: 'timestamptz' })
+  createdAt!: Date;
+
+  @DeleteDateColumn({ type: 'timestamptz' })
+  deletedAt!: Date | null;
+
+  @UpdateDateColumn({ type: 'timestamptz' })
+  updatedAt!: Date;
+
+  @OneToMany(() => TagEntity, (tag) => tag.user)
+  tags!: TagEntity[];
+
+  @OneToMany(() => AssetEntity, (asset) => asset.owner)
+  assets!: AssetEntity[];
+}