@sidekick-coder/zenith-kit 0.3.6 → 0.3.8

package/src/server/repositories/FileRepository.ts

@@ -0,0 +1,52 @@
+import DatabaseRepository from '#server/repositories/DatabaseRepository.ts'
+import type { MetadataQueryPayload } from '#server/services/MetadataQueryService.ts'
+import MetadataQueryService from '#server/services/MetadataQueryService.ts'
+import type FileEntity from '#shared/entities/FileEntity.ts'
+
+export interface FileRepositoryQueryOptions {
+    id?: number | number[]
+    search?: string
+    purpose?: string[]
+    client_name?: string[]
+    metas?: MetadataQueryPayload
+}
+
+export default class FileRepository extends DatabaseRepository<
+    FileEntity,
+    FileEntity['id'],
+    FileRepositoryQueryOptions
+> {
+    constructor(db: DatabaseRepository['db']) {
+        super(db, 'files', 'id')
+    }
+
+    public query(options?: FileRepositoryQueryOptions) {
+        let qb = super.query(options as any)
+
+        if (options?.id) {
+            const ids = Array.isArray(options.id) ? options.id : [options.id]
+
+            qb = qb.where('id', 'in', ids)
+        }
+
+        if (options?.search) {
+            qb = qb.where('f.client_name', 'like', `%${options.search}%`)
+        }
+
+        if (options?.purpose?.length) {
+            qb = qb.where('f.purpose', 'in', options.purpose)
+        }
+
+        if (options?.client_name?.length) {
+            qb = qb.where('f.client_name', 'in', options.client_name)
+        }
+
+        if (options?.metas) {
+            const metasQueryService = new MetadataQueryService(options.metas, 'file_metas', 'file_id')
+
+            qb = metasQueryService.apply(qb)
+        }
+
+        return qb
+    }
+}

package/src/server/repositories/GitBranchRepository.ts

@@ -0,0 +1,48 @@
+import ShellService from "#server/services/ShellService.ts"
+import GitBranchEntity from "#shared/entities/GitBranchEntity.ts"
+
+export interface GitBranchRepositoryOptions {
+    cwd: string
+    shell?: ShellService
+}
+
+export default class GitBranchRepository {
+    public cwd: string
+    public shell: ShellService
+
+    constructor(options: GitBranchRepositoryOptions) {
+        this.cwd = options.cwd
+        this.shell = options.shell ?? new ShellService()
+    }
+
+    async list(): Promise<GitBranchEntity[]> {
+        const output = await this.shell.executeCommandWithOutput(
+            'git',
+            ['branch', '-a', `--format='%(HEAD)|%(refname:short)|%(refname)|%(upstream:remotename)'`],
+            { cwd: this.cwd },
+        )
+
+        return output
+            .split('\n')
+            .filter(Boolean)
+            .filter((line) => line.includes('|'))
+            .map((line) => {
+                const [head, refShort, refFull, remoteName] = line.split('|')
+
+                const isRemote = refFull.startsWith('refs/remotes/')
+
+                return new GitBranchEntity({
+                    name: refShort,
+                    remote: isRemote ? refShort.split('/')[0] : remoteName || null,
+                    is_current: head === '*',
+                    is_remote: isRemote,
+                })
+            })
+    }
+
+    async fetch(options: { remote: string; branch: string; localName?: string }): Promise<void> {
+        const { remote, branch, localName = branch } = options
+
+        await this.shell.command('git', ['fetch', remote, `${branch}:${localName}`], { cwd: this.cwd })
+    }
+}

package/src/server/repositories/GitCommitRepository.ts

@@ -0,0 +1,87 @@
+import ShellService from "#server/services/ShellService.ts"
+import GitCommitEntity from "#shared/entities/GitCommitEntity.ts"
+
+export interface GitCommitRepositoryOptions {
+    cwd: string
+    shell?: ShellService
+}
+
+export interface GitCommitListOptions {
+    limit?: number
+    cursor?: string
+    branches?: string | string[]
+}
+
+export interface GitCommitListResult {
+    items: GitCommitEntity[]
+    cursor_previous: string | null
+    cursor_current: string | null
+    cursor_next: string | null
+}
+
+// %H = full hash, %h = short hash, %s = subject, %an = author name, %ae = author email, %aI = author date (ISO 8601), %b = body
+const LOG_FORMAT = ['%H', '%h', '%s', '%an', '%ae', '%aI', '%b'].join('%x09')
+const COMMIT_SEPARATOR = '---COMMIT---'
+
+export default class GitCommitRepository {
+    public cwd: string
+    public shell: ShellService
+
+    constructor(options: GitCommitRepositoryOptions) {
+        this.cwd = options.cwd
+        this.shell = options.shell ?? new ShellService()
+    }
+
+    async list(options?: GitCommitListOptions): Promise<GitCommitListResult> {
+        const limit = options?.limit ?? 20
+        const cursor = options?.cursor
+
+        const args = ['log', `--format=${COMMIT_SEPARATOR}%n${LOG_FORMAT}`, `-n`, String(limit)]
+
+        if (cursor) args.push(`${cursor}^`)
+
+        if (options?.branches) {
+            const branches = Array.isArray(options.branches) ? options.branches : [options.branches]
+            args.push(...branches)
+        }
+
+        if (!options?.branches && !cursor) {
+            args.push('--all')
+        }
+
+        const output = await this.shell.executeCommandWithOutput('git', args, { cwd: this.cwd })
+
+        const items = output
+            .split(COMMIT_SEPARATOR)
+            .map((block) => block.trim())
+            .filter(Boolean)
+            .map((block) => {
+                const [hash, shortHash, message, authorName, authorEmail, date, ...bodyParts] =
+                    block.split('\t')
+
+                return new GitCommitEntity({
+                    hash,
+                    short_hash: shortHash,
+                    message,
+                    author_name: authorName,
+                    author_email: authorEmail,
+                    date,
+                    body: bodyParts.join('\t').trim(),
+                })
+            })
+
+        const cursor_current = items[0]?.hash ?? null
+        const cursor_next = items[items.length - 1]?.hash ?? null
+
+        return {
+            items,
+            cursor_previous: cursor ?? null,
+            cursor_current,
+            cursor_next: items.length < limit ? null : cursor_next,
+        }
+    }
+
+    public async checkout(hash: string): Promise<void> {
+        await this.shell.command('git', ['checkout', hash], { cwd: this.cwd })
+    }
+}

package/src/server/repositories/PermissionAssignmentRepository.ts

@@ -0,0 +1,49 @@
+import DatabaseRepository from '#server/repositories/DatabaseRepository.ts'
+import type { PermissionAssignment } from '#shared/schemas/permissionAssignmentSchema.ts'
+
+export interface PermissionAssignmentRepositoryQueryOptions {
+    id?: number | number[]
+    permissionId?: number | number[]
+    assignableId?: string | string[]
+    assignableType?: string | string[]
+}
+
+export default class PermissionAssignmentRepository extends DatabaseRepository<
+    PermissionAssignment,
+    PermissionAssignment['id'],
+    PermissionAssignmentRepositoryQueryOptions
+> {
+    constructor(db: DatabaseRepository['db']) {
+        super(db, 'permissions_assignments', 'id')
+    }
+
+    public query(options?: PermissionAssignmentRepositoryQueryOptions) {
+        let qb = super.query(options as any)
+
+        if (options?.id) {
+            const ids = Array.isArray(options.id) ? options.id : [options.id]
+
+            qb = qb.where('id', 'in', ids)
+        }
+
+        if (options?.permissionId) {
+            const permissionIds = Array.isArray(options.permissionId) ? options.permissionId : [options.permissionId]
+
+            qb = qb.where('permission_id', 'in', permissionIds)
+        }
+
+        if (options?.assignableId) {
+            const assignableIds = Array.isArray(options.assignableId) ? options.assignableId : [options.assignableId]
+
+            qb = qb.where('assignable_id', 'in', assignableIds)
+        }
+
+        if (options?.assignableType) {
+            const assignableTypes = Array.isArray(options.assignableType) ? options.assignableType : [options.assignableType]
+
+            qb = qb.where('assignable_type', 'in', assignableTypes)
+        }
+
+        return qb
+    }
+}

package/src/server/repositories/PermissionRepository.test-d.ts

@@ -0,0 +1,20 @@
+import { test, expectTypeOf, describe } from 'vitest'
+import PermissionRepository from './PermissionRepository'
+import type { Permission } from '#shared/schemas/permissionSchema.ts'
+
+describe('PermissionRepository', () => {
+    const repository = {} as any as PermissionRepository
+
+    test('should findMany return permissions array', () => {
+        expectTypeOf(repository.findMany()).resolves.toEqualTypeOf<Permission[]>()
+    })
+
+    test('should findById return a permission or null', () => {
+        expectTypeOf(repository.findById(1)).resolves.toEqualTypeOf<Permission | null>()
+    })
+
+    test('should findByIdOrFail return a permission', () => {
+        expectTypeOf(repository.findByIdOrFail(1)).resolves.toEqualTypeOf<Permission>()
+    })
+})
+

package/src/server/repositories/PermissionRepository.ts

@@ -0,0 +1,33 @@
+import DatabaseRepository from '#server/repositories/DatabaseRepository.ts'
+import type { Permission } from '#shared/schemas/permissionSchema.ts'
+
+export interface PermissionRepositoryQueryOptions {
+    id?: number | number[]
+    search?: string
+}
+
+export default class PermissionRepository extends DatabaseRepository<
+    Permission,
+    Permission['id'],
+    PermissionRepositoryQueryOptions
+> {
+    constructor(db: DatabaseRepository['db']) {
+        super(db, 'permissions', 'id')
+    }
+
+    public query(options?: PermissionRepositoryQueryOptions) {
+        let qb = super.query(options as any)
+
+        if (options?.id) {
+            const ids = Array.isArray(options.id) ? options.id : [options.id]
+
+            qb = qb.where('id', 'in', ids)
+        }
+
+        if (options?.search) {
+            qb = qb.where('name', 'like', `%${options.search}%`)
+        }
+
+        return qb
+    }
+}

package/src/server/repositories/TokenRepository.ts

@@ -0,0 +1,78 @@
+import DatabaseRepositoryInfer from '#server/mixins/DatabaseRepositoryInferMixin.ts'
+import DatabaseRepository from '#server/repositories/DatabaseRepository.ts'
+import { compose, mixin } from '#shared/utils/index.ts'
+import type { Token } from '#shared/schemas/tokenSchema.ts'
+import { randomBytes } from 'crypto'
+
+export interface TokenRepositoryQueryOptions {
+    id?: number | number[]
+    search?: string
+    type?: string | string[]
+}
+
+export interface TokenRepositoryGenerateOptions {
+    user_id: number
+    type?: string
+    expires_in_hours?: number
+}
+
+export default class TokenRepository extends compose(
+    mixin(DatabaseRepository),
+    DatabaseRepositoryInfer<Token, Token['id'], TokenRepositoryQueryOptions>()
+) {
+    public autoCreatedAt: boolean = true
+    public autoUpdatedAt: boolean = false
+
+    constructor(db: DatabaseRepository['db']) {
+        super(db, 'tokens', 'id')
+    }
+
+    public query(options?: TokenRepositoryQueryOptions) {
+        let qb = super.query(options as any)
+
+        if (options?.id) {
+            const ids = Array.isArray(options.id) ? options.id : [options.id]
+
+            qb = qb.where('id', 'in', ids)
+        }
+
+        if (options?.search) {
+            qb = qb.where('name', 'like', `%${options.search}%`)
+        }
+
+        if (options?.type) {
+            const types = Array.isArray(options.type) ? options.type : [options.type]
+
+            qb = qb.where('type', 'in', types)
+        }
+
+        return qb
+    }
+
+    public async findByToken(token: string): Promise<Token | null> {
+        let qb = this.query() as any
+
+        qb = qb.selectAll()
+
+        qb = qb.where('token', '=', token)
+
+        const item = await qb.executeTakeFirst()
+
+        return item || null
+    }
+
+    async generate(options: TokenRepositoryGenerateOptions) {
+        const token = randomBytes(64).toString('hex')
+
+        const expiresAt = options.expires_in_hours
+            ? new Date(Date.now() + options.expires_in_hours * 60 * 60 * 1000)
+            : null
+
+        return await this.create({
+            user_id: options.user_id,
+            token,
+            type: options.type || 'auth',
+            expires_at: expiresAt
+        })
+    }
+}

package/src/server/repositories/UserRepository.ts

@@ -0,0 +1,99 @@
+import emmitter from '#server/facades/emmitter.ts'
+import hasher from '#server/facades/hasher.ts'
+import type { UserEntity } from '#shared/index.ts'
+import DatabaseRepository from './DatabaseRepository'
+
+export interface UserRepositoryQueryOptions {
+    id?: number | number[]
+    search?: string
+    email?: string
+    username?: string
+    showDeleted?: boolean
+}
+
+export interface UserRepositoryEvents {
+    'user:created': {
+        user: UserEntity
+    }
+    'user:updated': {
+        user: UserEntity
+    }
+    'user:deleted': {
+        user: UserEntity
+    }
+}
+
+export default class UserRepository extends DatabaseRepository<UserEntity, number, UserRepositoryQueryOptions> {
+    public static __container_entry_key = 'UserRepository'
+    public autoCreatedAt = true 
+    public autoUpdatedAt = true
+
+    constructor(db: DatabaseRepository['db']) {
+        super(db, 'users', 'id')
+    }
+
+    public async hashUserPasswordIfDefined(data: Partial<UserEntity>) {
+        if (data.password) {
+            data.password = await hasher.hash(data.password)
+        }
+    }
+
+    protected async beforeCreate(data: Partial<UserEntity>) {
+        await this.hashUserPasswordIfDefined(data)
+
+        return data
+    }
+
+    protected async beforeCreateMany(data: Partial<UserEntity>[]): Promise<Partial<UserEntity>[]> {
+        for (const item of data) {
+            await this.hashUserPasswordIfDefined(item)
+        }
+
+        return data
+    }
+
+    protected async beforeUpdate(data: Partial<UserEntity>) {
+        await this.hashUserPasswordIfDefined(data)
+
+        return data
+    }
+
+    protected async afterCreate(data: UserEntity): Promise<void> {
+        emmitter.emit('user:created', {
+            user: data
+        })
+    }
+
+    public query(options: UserRepositoryQueryOptions = {}) {
+        let query = super.query(options)
+
+        if (!options.showDeleted) {
+            query = query.where('deleted_at', 'is', null)
+        }
+
+        if (options.search) {
+            query = query.where((eb: any) => eb.or([
+                eb('name', 'like', `%${options.search}%`),
+                eb('username', 'like', `%${options.search}%`),
+                eb('email', 'like', `%${options.search}%`),
+            ]))
+        }
+
+        // Apply options
+        if (options?.email) {
+            query = query.where('email', '=', options.email)
+        }
+
+        if (options?.username) {
+            query = query.where('username', 'like', `%${options.username}%`)
+        }
+
+        if (options?.id) {
+            const ids = Array.isArray(options.id) ? options.id : [options.id]
+
+            query = query.where('id', 'in', ids)
+        }
+
+        return query
+    }
+}

package/src/server/schemas/envSchema.ts

@@ -0,0 +1,78 @@
+import * as v from 'valibot'
+import { set } from 'lodash-es'
+
+export type EnvSchema = v.InferOutput<typeof envSchema>
+
+const boolean = v.pipe(
+    v.union([v.literal('true'), v.literal('false'), v.literal('1'), v.literal('0')]),
+    v.transform((value) => value === 'true' || value === '1'),
+    v.boolean()
+)
+
+const keyValue = v.pipe(v.string(), v.transform((value) => {
+    const entries = value.split(/[;\n]/)
+        .filter(Boolean)
+        .filter(l => l.includes('='))
+        .map(l => l.trim().split('='))
+
+    const obj = Object.fromEntries(entries) as Record<string, string>
+
+    const result: Record<string, any> = {}
+
+    for (const [key, value] of Object.entries(obj)) {
+        let parsedValue: any = value
+
+        if (value.startsWith('bool:')) {
+            parsedValue = value.replace('bool:', '').trim() === 'true'
+        }
+
+        set(result, key, parsedValue)
+    }
+
+    return result
+}))
+
+const stringArray = v.pipe(
+    v.string(),
+    v.transform((value) => value
+        .split(',')
+        .map(s => s.trim())
+        .filter(Boolean)
+    )
+)
+
+export const envSchema = v.looseObject({
+    NODE_ENV: v.optional(v.union([v.literal('development'), v.literal('production'), v.literal('test')]), 'development'),
+
+    ZENITH_BASE_PATH: v.string(),
+    ZENITH_STORAGE_PATH: v.optional(v.string()),
+
+    ZENITH_APP_URL: v.optional(v.string(), 'http://localhost:3000'),
+    ZENITH_PORT: v.optional(v.pipe(v.string(), v.transform((value) => parseInt(value))), '3000'),
+    ZENITH_HOST: v.optional(v.string(), '0.0.0.0'),
+
+    ZENITH_LOG_LEVEL: v.optional(v.picklist(['error', 'warn', 'info', 'debug']), 'info'),
+    ZENITH_LIFECYCLE_DEBUG: v.optional(boolean, 'false'),
+    ZENITH_CLIENT_CONFIG: v.optional(keyValue, ''),
+
+    ZENITH_CONFIG: v.optional(keyValue, ''),
+    ZENITH_CONFIG_ARGUMENTS: v.optional(keyValue, ''),
+    ZENITH_CONFIG_FILES: v.optional(stringArray, ''),
+
+    ZENITH_CONFIG_DEBUG: v.optional(boolean, 'false'),
+    ZENITH_CONFIG_DRIVER: v.optional(v.picklist(['fs', 's3']), 'fs'),
+    ZENITH_CONFIG_FS_PATH: v.optional(v.string()),
+    ZENITH_CONFIG_FS_FORMAT: v.optional(v.picklist(['json', 'yml']), 'json'),
+    ZENITH_CONFIG_FS_FORMAT_OPTIONS: v.optional(keyValue, ''),
+
+    ZENITH_CONFIG_S3_BUCKET: v.optional(v.string()),
+    ZENITH_CONFIG_S3_REGION: v.optional(v.string()),
+    ZENITH_CONFIG_S3_ACCESS_KEY_ID: v.optional(v.string()),
+    ZENITH_CONFIG_S3_SECRET_ACCESS_KEY: v.optional(v.string()),
+    ZENITH_CONFIG_S3_SESSION_TOKEN: v.optional(v.string()),
+    ZENITH_CONFIG_S3_ENDPOINT: v.optional(v.string()),
+    ZENITH_CONFIG_S3_PREFIX: v.optional(v.string(), ''),
+
+    ZENITH_PLUGINS_DIRS: v.optional(stringArray, ''),
+})
+

package/src/server/services/CliService.ts

@@ -0,0 +1,121 @@
+import { Command as CommanderCommand } from 'commander'
+import chalk from 'chalk'
+import { printTable, printObject } from '../utils/printTable.ts'
+import { importAll } from '#server/utils/importAll.ts'
+import { EmmitterService, LoggerService, tryCatch } from '#shared/index.ts'
+import * as inquirer from '@inquirer/prompts'
+
+export interface CliEvents {
+    'cli:registered': {
+        cli: CliService
+    }
+}
+
+export class CliCommand extends CommanderCommand {
+    public __is_cli_command = true
+    public table = printTable
+    public object = printObject
+    public colors = chalk
+    public inquirer = inquirer
+
+    public needs: Set<string> = new Set()
+    public need(...args: string[]): this {
+        args.forEach(arg => this.needs.add(arg))
+
+        return this
+    }
+
+    createCommand(name?: string) {
+        return new CliCommand(name)
+    }
+}
+
+export default class CliService extends CliCommand {
+    public static __container_entry_key = 'CliService'
+
+    public dirs = new Set<string>()
+    public logger = new LoggerService()
+    public emmitter = new EmmitterService()
+    public debug = false
+
+    public static create(name = 'cli') {
+        return new CliService(name)
+    }
+
+    public setLogger(logger: LoggerService) {
+        this.logger = logger
+
+        return this
+    }
+
+    public setDebug(debug: boolean) {
+        this.debug = debug
+
+        return this
+    }
+
+    public setEmmitter(emmitter: EmmitterService) {
+        this.emmitter = emmitter
+
+        return this
+    }
+
+    createCommand(name?: string) {
+        return new CliService(name)
+    }
+
+    public addDir(dir: string) {
+        this.dirs.add(dir)
+
+        return this
+    }
+
+    public async loadDir(dir: string) {
+        const mods = await importAll(dir, {
+            exclude: ['.test.ts', '.spec.ts', '.test.js', '.spec.js'],
+            onError: ({ error, filename }) => {
+                Object.assign(error, { filename })
+
+                this.logger.error(error.message, error)
+            }
+        })
+
+        for (const [filename, mod] of Object.entries(mods)) {
+            if (this.debug) {
+                this.logger.debug(`imported file ${filename} from ${dir}`)
+            }
+
+            if (!mod.default || Object.keys(mod.default).length === 0) {
+                continue
+            }
+
+            if (!mod.default.__is_cli_command) {
+                this.logger.warn(`default export of file ${mod.filename} is not a CliCommand, skipping`)
+                continue
+            }
+
+            const [error] = tryCatch.sync(() => this.addCommand(mod.default))
+
+            if (error) {
+                Object.assign(error, { filename: mod.filename })
+
+                this.logger.error(error.message, error)
+
+                continue
+            }
+
+            if (this.debug) {
+                this.logger.debug(`added command from file ${filename} to cli`)
+            }
+
+        }
+    }
+
+    public async load() {
+        for (const dir of this.dirs) {
+            await this.loadDir(dir)
+        }
+
+        return this
+    }
+}