@sidekick-coder/zenith-kit 0.3.6 → 0.3.8

package/src/server/relations/BelongsToUserRelation.ts

@@ -0,0 +1,18 @@
+import BelongsTo from './BelongsToRelation.ts'
+import User from '#shared/entities/UserEntity.ts'
+
+export default class BelongsToUser extends BelongsTo {
+    constructor() {
+        super({
+            table: 'users',
+            tableKey: 'id',
+            
+            targetTable: 'users',
+            targetKey: 'user_id',
+
+            property: 'user',
+            serialize: row => User.from(row)
+        })
+
+    }
+}

package/src/server/relations/HasManyRelation.ts

@@ -0,0 +1,62 @@
+import type { DatabaseContract as  Database } from '#server/contracts/DatabaseContract.ts'
+import db from '#server/facades/database.ts'
+
+interface HasManyOptions {
+    table: keyof Database
+    tableKey: string
+    
+    targetTable: keyof Database
+    targetKey: string
+
+    property: string
+    serialize?: (row: any) => any
+    after?: (rows: any[]) => Promise<any>
+}
+
+export default class HasMany {
+    public table: string
+    public tableKey: string
+    
+    public targetTable: string
+    public targetKey: string
+
+    public property: string
+    public serialize: (row: any) => any
+    public after: (rows: any[]) => Promise<any>
+
+    constructor(options: HasManyOptions) {
+        this.table = options.table
+        this.tableKey = options.tableKey
+        
+        this.targetTable = options.targetTable
+        this.targetKey = options.targetKey
+        
+        this.property = options.property
+        this.serialize = options.serialize || ((row: any) => row)
+        this.after = options.after || (async (rows: any[]) => rows)
+
+    }
+
+    async load(entities: any[]) {
+        const ids = new Set()
+
+        entities.forEach(e => ids.add(e[this.tableKey]))
+        
+        if (!ids.size) return
+
+        const query = db.selectFrom(this.targetTable as any) as any
+
+        // Assumes your models have a standard .list() or .where()
+        const results = await query.selectAll()
+            .where(this.targetKey, 'in', Array.from(ids))
+            .execute()
+
+        const rows = results.map((r: any) => this.serialize(r))
+        
+        entities.forEach(e => {
+            e[this.property] = rows.filter((r: any) => r[this.targetKey] === e[this.tableKey])
+        })
+
+        await this.after(rows)
+    }
+}

package/src/server/relations/HasMetasRelation.ts

@@ -0,0 +1,56 @@
+import { set } from 'lodash-es'
+import type { DatabaseContract as  Database } from '#server/contracts/DatabaseContract.ts'
+import db from '#server/facades/database.ts'
+import MetadataService from '#server/services/MetadataService.ts'
+
+interface HasMetasOptions {
+    table: keyof Database
+    tableKey: string
+    
+    targetTable: keyof Database
+    targetKey: string
+
+    property: string
+}
+
+export default class HasMetas {
+    public table: string
+    public tableKey: string
+    
+    public targetTable: string
+    public targetKey: string
+
+    public property: string
+
+    constructor(options: HasMetasOptions) {
+        this.table = options.table
+        this.tableKey = options.tableKey
+        
+        this.targetTable = options.targetTable
+        this.targetKey = options.targetKey
+        
+        this.property = options.property
+    }
+
+    async load(entities: any[]) {
+        const ids = new Set()
+
+        entities.forEach(e => ids.add(e[this.tableKey]))
+        
+        if (!ids.size) return
+
+        let query = db.selectFrom(this.targetTable as any) as any
+
+        query = query.selectAll().where(this.targetKey, 'in', Array.from(ids))
+
+        // Assumes your models have a standard .list() or .where()
+        const results = await query.execute()
+            
+        entities.forEach(e => {
+            const rows = results.filter((r: any) => r[this.targetKey] === e[this.tableKey])
+            
+            set(e, this.property, MetadataService.flatten(rows))
+        })
+
+    }
+}

package/src/server/relations/hasManyThroughRelation.ts

@@ -0,0 +1,82 @@
+import BaseRelation from './BaseRelation.ts'
+import type { DatabaseContract as  Database } from '#server/contracts/DatabaseContract.ts'
+import db from '#server/facades/database.ts'
+
+interface HasManyThroughOptions {
+    table: keyof Database
+    tableKey: string
+    
+    targetTable: keyof Database
+    targetKey: string
+    
+    pivotTable: keyof Database
+    pivotSourceKey: string
+    pivotTargetKey: string
+
+    property: string
+    serialize?: (row: any) => any
+    after?: (rows: any[]) => Promise<any>
+}
+
+export default class HasManyThrough extends BaseRelation {
+    public table: string
+    public tableKey: string
+    
+    public targetTable: string
+    public targetKey: string
+    
+    public pivotTable: string
+    public pivotSourceKey: string
+    public pivotTargetKey: string
+
+    public property: string
+    public serialize: (row: any) => any
+    public after: (rows: any[]) => Promise<any>
+
+    constructor(options: HasManyThroughOptions) {
+        super()
+        this.table = options.table
+        this.tableKey = options.tableKey
+        
+        this.targetTable = options.targetTable
+        this.targetKey = options.targetKey
+        
+        this.pivotTable = options.pivotTable
+        this.pivotSourceKey = options.pivotSourceKey
+        this.pivotTargetKey = options.pivotTargetKey
+        
+        this.property = options.property
+        this.serialize = options.serialize || ((row: any) => row)
+        this.after = options.after || (async (rows: any) => rows)
+    }
+
+    async load(entities: any[]) {
+        const ids = new Set()
+
+        entities.forEach(e => ids.add(e[this.tableKey]))
+
+        if (!ids.size) return
+
+        const query = db.selectFrom(this.targetTable as any) as any
+
+        const results = await query
+            .selectAll(this.targetTable)
+            .innerJoin(
+                this.pivotTable as any,
+                `${this.targetTable}.${this.targetKey}`,
+                `${this.pivotTable}.${this.pivotTargetKey}`
+            )
+            .where(`${this.pivotTable}.${this.pivotSourceKey}`, 'in', Array.from(ids))
+            .execute()
+
+        const rows = results.map((r: any) => this.serialize(r))
+        
+        entities.forEach(e => {
+            e[this.property] = rows.filter((r: any) => {
+                return r[this.pivotSourceKey] === e[this.tableKey]
+            })
+        })
+
+        await this.after(entities)
+    }
+}

package/src/server/repositories/ConfigRepository.ts

@@ -0,0 +1,160 @@
+import { orderBy } from 'lodash-es'
+import BaseException from '#shared/exceptions/BaseException.ts'
+import type ConfigService from '#shared/services/ConfigService.ts'
+import { createId } from '#shared/utils/createId.ts'
+
+import type { Pagination, FindManyOptions, PaginateOptions, DeleteManyOptions } from '#server/repositories/DatabaseRepository.ts'
+
+export default class ConfigRepository<
+    TEntity = Record<string, any>,
+    TOptions = Record<string, any>
+> {
+    constructor(
+        protected config: ConfigService,
+        protected key: string,
+        protected primaryKey: string = 'id'
+    ) {}
+
+    protected getItems(): TEntity[] {
+        return this.config.get<TEntity[]>(this.key, [])
+    }
+
+    protected setItems(items: TEntity[]): void {
+        this.config.set(this.key, items)
+    }
+
+    // @ts-expect-error - allow passing options for filtering in subclasses 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    public query(options?: TOptions): TEntity[] {
+        return this.getItems()
+    }
+
+    async count(options?: TOptions): Promise<number> {
+        return this.query(options).length
+    }
+
+    async findMany(options?: FindManyOptions & TOptions): Promise<TEntity[]> {
+        let items = this.query(options)
+
+        if (options?.orderBy) {
+            const fields = Array.isArray(options.orderBy) ? options.orderBy : [options.orderBy]
+            const directions = Array.isArray(options.orderDirection)
+                ? options.orderDirection
+                : [options.orderDirection ?? 'asc']
+
+            items = orderBy(items, fields, directions)
+        }
+
+        if (options?.offset) {
+            items = items.slice(options.offset)
+        }
+
+        if (options?.limit) {
+            items = items.slice(0, options.limit)
+        }
+
+        return items
+    }
+
+    async findOne(options?: TOptions): Promise<TEntity | null> {
+        const items = this.query(options)
+
+        return items[0] ?? null
+    }
+
+    async findById(id: string, options?: TOptions): Promise<TEntity | null> {
+        const items = this.query(options)
+
+        return items.find(item => (item as any)[this.primaryKey] === id) ?? null
+    }
+
+    async findByIdOrFail(id: string, options?: TOptions): Promise<TEntity> {
+        const item = await this.findById(id, options)
+
+        if (!item) {
+            throw new BaseException('Item not found', 404)
+        }
+
+        return item
+    }
+
+    async paginate(options?: PaginateOptions & TOptions): Promise<Pagination<TEntity>> {
+        const page = options?.page ?? 1
+        const limit = options?.limit ?? 10
+        const offset = (page - 1) * limit
+
+        const [items, total] = await Promise.all([
+            this.findMany({ ...options, limit, offset } as any),
+            this.count(options as any),
+        ])
+
+        return {
+            items,
+            page,
+            per_page: limit,
+            total,
+            total_pages: Math.ceil(total / limit),
+        }
+    }
+
+    async create(data: Partial<TEntity>): Promise<TEntity> {
+        const items = this.getItems()
+
+        const item = {
+            [this.primaryKey]: createId(),
+            ...data,
+        } as TEntity
+
+        items.push(item)
+        this.setItems(items)
+
+        return item
+    }
+
+    async createMany(data: Partial<TEntity>[]): Promise<TEntity[]> {
+        const items = this.getItems()
+
+        const created = data.map(d => ({
+            [this.primaryKey]: createId(),
+            ...d,
+        } as TEntity))
+
+        this.setItems([...items, ...created])
+
+        return created
+    }
+
+    async updateById(id: string, data: Partial<TEntity>): Promise<TEntity> {
+        const items = this.getItems()
+        const index = items.findIndex(item => (item as any)[this.primaryKey] === id)
+
+        if (index === -1) {
+            throw new BaseException('Item not found', 404)
+        }
+
+        items[index] = { ...items[index], ...data }
+        this.setItems(items)
+
+        return items[index]
+    }
+
+    async deleteById(id: string): Promise<void> {
+        await this.findByIdOrFail(id)
+
+        const items = this.getItems().filter(item => (item as any)[this.primaryKey] !== id)
+
+        this.setItems(items)
+    }
+
+    async deleteMany(options?: DeleteManyOptions & TOptions): Promise<void> {
+        const toDelete = this.query(options as any)
+        const limit = options?.limit ?? toDelete.length
+        const toDeleteIds = new Set(
+            toDelete.slice(0, limit).map(item => (item as any)[this.primaryKey])
+        )
+
+        const remaining = this.getItems().filter(item => !toDeleteIds.has((item as any)[this.primaryKey]))
+
+        this.setItems(remaining)
+    }
+}

package/src/server/repositories/DatabaseRepository.ts

@@ -0,0 +1,293 @@
+import type { Kysely } from 'kysely'
+import BaseException from '#shared/exceptions/BaseException.ts'
+import { now } from '../queries'
+import { set } from 'lodash-es'
+
+export interface Pagination<T = any> {
+    items: T[]
+    page: number
+    per_page: number
+    total: number
+    total_pages: number
+}
+
+export interface FindManyOptions {
+    limit?: number
+    offset?: number
+    orderBy?: string | string[]
+    orderDirection?: 'asc' | 'desc' | ('asc' | 'desc')[]
+}
+
+export interface PaginateOptions {
+    page?: number
+    limit?: number
+    orderBy?: FindManyOptions['orderBy']
+    orderDirection?: FindManyOptions['orderDirection']
+}
+
+export interface DeleteManyOptions {
+    limit?: number
+}
+
+export default class DatabaseRepository<
+    TEntity = Record<string, any>,
+    TPrimaryKey = any,
+    TOptions = Record<string, any>
+> {
+
+    public autoCreatedAt = false
+    public autoUpdatedAt = false
+
+    constructor(
+        protected db: Kysely<any>, 
+        protected table: string, 
+        protected primaryKey: string
+    ) {    }
+
+
+    public query(options?: { qb?: any } & TOptions) {
+        const qb = options?.qb || this.db.selectFrom(this.table as any)
+
+        return qb
+    }
+
+    async count(options?: Record<string, any>) {
+        let qb = this.query(options as any) as any
+
+        qb = qb.select((eb: any) => eb.fn.countAll().as('count'))
+
+        const result = await qb.executeTakeFirstOrThrow()
+
+        return Number(result.count)
+    }
+
+    async findMany(options?: FindManyOptions & TOptions): Promise<TEntity[]> {
+        let qb = this.query(options) as any
+
+        qb = qb.selectAll()
+
+        if (options?.limit !== undefined) {
+            qb = qb.limit(options.limit)
+        }
+
+        if (options?.offset !== undefined) {
+            qb = qb.offset(options.offset)
+        }
+
+        if (options?.orderBy) {
+            const orderBy = Array.isArray(options.orderBy) ? options.orderBy : [options.orderBy]
+            const orderDirection = Array.isArray(options.orderDirection) ? options.orderDirection : [options.orderDirection ?? 'asc']
+
+            orderBy.forEach((ob, index) => {
+                qb = qb.orderBy(ob, orderDirection[index] || 'asc')
+            })
+        }
+
+        return await qb.execute()
+    }
+
+    async findOne(options?: TOptions): Promise<TEntity | null> {
+        let qb = this.query(options as any) as any
+
+        qb = qb.selectAll()
+
+        const item = await qb.executeTakeFirst()
+
+        return item
+    }
+
+    async findById(id: TPrimaryKey, options?: TOptions): Promise<TEntity | null> {
+        let qb = this.query(options as any) as any
+
+        qb = qb.selectAll()
+
+        qb = qb.where(this.primaryKey, '=', id)
+
+        const item = await qb.executeTakeFirst()
+
+        return item
+    }
+
+    async findByIdOrFail(id: TPrimaryKey, options?: TOptions) {
+        const item = await this.findById(id, options)
+
+        if (!item) {
+            throw new BaseException('Item not found', 404)
+        }
+
+        return item
+    }
+
+    public async paginate(options?: PaginateOptions & TOptions): Promise<Pagination> {
+        const page = options?.page ?? 1
+        const offset = (page - 1) * (options?.limit ?? 10)
+        const limit = options?.limit ?? 10
+
+        const findAllOptions = {
+            ...options,
+            limit,
+            offset
+        }
+
+        const countOptions = { ...options }
+
+        const [items, totalItems] = await Promise.all([
+            this.findMany(findAllOptions as any),
+            this.count(countOptions as any)
+        ])
+
+        return {
+            items,
+            page,
+            per_page: limit,
+            total: totalItems,
+            total_pages: Math.ceil(totalItems / limit)
+        }
+    }
+
+    protected async beforeCreate(data: Partial<TEntity>): Promise<Partial<TEntity>> {
+        return data
+    }
+
+    // @ts-expect-error ignore non used parameter it will be used by the child class
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    protected async afterCreate(data: TEntity): Promise<void> {}
+
+    public async create(data: Partial<TEntity>): Promise<TEntity> {
+        if (this.autoCreatedAt) {
+            set(data, 'created_at', now())
+        }
+
+        if (this.autoUpdatedAt) {
+            set(data, 'updated_at', now())
+        }
+
+        data = await this.beforeCreate(data) 
+
+        let qb = this.db.insertInto(this.table as any) as any
+
+        qb = qb.values(data).returningAll()
+
+        const result = await qb.executeTakeFirst()
+
+        await this.afterCreate(result)
+
+        return result as any
+    }
+
+    protected async beforeCreateMany(data: Partial<TEntity>[]): Promise<Partial<TEntity>[]> {
+        return data
+    }
+
+    protected async afterCreateMany(data: TEntity[]): Promise<TEntity[]> {
+        return data
+    }
+
+    public async createMany(data: Partial<TEntity>[]) {
+        if (this.autoCreatedAt) {
+            data = data.map(item => {
+                set(item, 'created_at', now())
+
+                return item
+            })
+        }
+        data = await this.beforeCreateMany(data) 
+
+        let qb = this.db.insertInto(this.table as any) as any
+
+        qb = qb.values(data).returningAll()
+
+        const result = await qb.execute()
+
+        await this.afterCreateMany(result)
+
+        return result as any[]
+    }
+
+    // @ts-expect-error ignore non used parameter it will be used by the child class
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    protected async beforeUpdate(data: Partial<TEntity>, id: TPrimaryKey): Promise<Partial<TEntity>> {
+        return data
+    }
+
+    protected async afterUpdate(data: TEntity): Promise<TEntity> {
+        return data
+    }
+
+    public async updateById(id: TPrimaryKey, data: Partial<TEntity>) {
+        if (this.autoUpdatedAt) {
+            set(data, 'updated_at', now())
+        }
+
+        data = await this.beforeUpdate(data, id) 
+
+        const row: Record<string, any> = await this.findByIdOrFail(id)
+
+        let qb = this.db.updateTable(this.table as any) as any
+
+        qb = qb.set(data)
+            .where(this.primaryKey, '=', row[this.primaryKey])
+            .returningAll()
+
+        const updated = await qb.executeTakeFirst()
+
+        await this.afterUpdate(updated)
+    }
+
+    // @ts-expect-error ignore non used parameter it will be used by the child class
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    protected async beforeDelete(id: TPrimaryKey): Promise<void> {
+
+    }
+
+    // @ts-expect-error ignore non used parameter it will be used by the child class
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    protected async afterDelete(id: TPrimaryKey): Promise<void> {
+
+    }
+
+    public async deleteById(id: TPrimaryKey) {
+        await this.beforeDelete(id)
+
+        const row: Record<string, any> = await this.findByIdOrFail(id)
+
+        let qb = this.db.deleteFrom(this.table as any) as any
+
+        qb = qb.where(this.primaryKey, '=', row[this.primaryKey])
+
+        await qb.executeTakeFirst()
+
+        await this.afterDelete(id)
+    }
+
+    protected beforeDeleteMany(options?: DeleteManyOptions & TOptions){
+        return options
+
+    }
+
+    // @ts-expect-error ignore non used parameter it will be used by the child class
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    protected afterDeleteMany(options?: DeleteManyOptions & TOptions): Promise<void> | void {
+
+    }
+
+    async deleteMany(options?: DeleteManyOptions & TOptions) {
+        options = this.beforeDeleteMany(options )
+
+        const deleteOptions = {
+            ...options,
+            qb: this.db.deleteFrom(this.table as any)
+        }
+
+
+        let qb = this.query(deleteOptions as any) as any
+
+        if (options?.limit) {
+            qb = qb.limit(options.limit)
+        }
+
+        await qb.execute()
+
+        await this.afterDeleteMany(options)
+    }
+}