feat: get records

Author: nichenqin

.dockerignore

@@ -13,4 +13,4 @@ helm-charts
 .editorconfig
 .idea
 coverage*
-undb
+.undb

Dockerfile

@@ -13,22 +13,30 @@ RUN cd /temp/dev && bun install --frozen-lockfile
 FROM base AS prerelease
 COPY --from=install /temp/dev/node_modules node_modules
 COPY . .
+RUN mkdir .undb
 
 ENV NODE_ENV=production
 ENV PORT=3000
 RUN bun run build
 
-FROM oven/bun:1.1-alpine AS release
+# Add Tini init-system
+ENV TINI_VERSION v0.19.0
+ADD https://github.com/krallin/tini/releases/download/${TINI_VERSION}/tini-static /tini
+RUN chmod +x /tini
+
+FROM gcr.io/distroless/base:nonroot AS release
 
 ENV NODE_ENV=production
 ENV PORT=3000
 
 WORKDIR /usr/src/app
 COPY --from=prerelease /usr/src/app/apps/backend/undb .
-RUN mkdir .undb
+COPY --from=prerelease /usr/src/app/.undb ./.undb
 COPY --from=prerelease /usr/src/app/apps/backend/drizzle ./drizzle
 COPY --from=prerelease /usr/src/app/apps/frontend/dist ./dist
+COPY --from=prerelease /tini /tini
 
 # run the app
 EXPOSE 3000/tcp
+ENTRYPOINT ["/tini", "--"]
 CMD [ "./undb" ]

apps/backend/src/registry/db.registry.ts

@@ -1,9 +1,9 @@
 import { container } from '@undb/di'
-import { RecordRepository, TableQueryRepository, TableRepository } from '@undb/persistence'
-import { RECORD_REPOSITORY, TABLE_QUERY_REPOSITORY, TABLE_REPOSITORY } from '@undb/table'
+import { RecordQueryRepository, TableQueryRepository, TableRepository } from '@undb/persistence'
+import { RECORD_QUERY_REPOSITORY, TABLE_QUERY_REPOSITORY, TABLE_REPOSITORY } from '@undb/table'
 
 export const registerDb = () => {
   container.register(TABLE_REPOSITORY, TableRepository)
   container.register(TABLE_QUERY_REPOSITORY, TableQueryRepository)
-  container.register(RECORD_REPOSITORY, RecordRepository)
+  container.register(RECORD_QUERY_REPOSITORY, RecordQueryRepository)
 }

apps/frontend/src/lib/components/blocks/grid-view/grid-view.svelte

@@ -18,9 +18,21 @@
 	import { cn } from '$lib/utils.js';
 	import { Input } from '$lib/components/ui/input/index.js';
 	import type { ITableDTO } from '@undb/table';
+	import { createQuery } from '@tanstack/svelte-query';
+	import { trpc } from '$lib/trpc/client';
 
 	export let t: ITableDTO;
 
+	$: tableId = t.id;
+
+	$: getRecords = createQuery({
+		queryKey: ['records', tableId],
+		queryHash: tableId,
+		queryFn: () => trpc.record.list.query({ tableId })
+	});
+
+	$: console.log($getRecords.data);
+
 	type Payment = {
 		id: string;
 		amount: number;

apps/frontend/src/routes/(authed)/t/[tableId]/+layout.ts

@@ -1,6 +1,8 @@
 import { trpc } from '$lib/trpc/client';
 import type { LayoutLoad } from './$types';
 
+export const prerender = 'auto';
+
 export const load: LayoutLoad = async (event) => {
 	const { tableId } = event.params;
 

bun.lockb

@@ -0,0 +1,43 @@
+import type { ISpecVisitor, ISpecification } from '@undb/domain'
+import type { ExpressionBuilder, ExpressionWrapper } from 'kysely'
+
+export interface IAbastractQBVisitor {
+  get cond(): ExpressionWrapper<any, any, any>
+}
+
+export abstract class AbstractQBVisitor<T> implements IAbastractQBVisitor, ISpecVisitor {
+  constructor(protected readonly eb: ExpressionBuilder<any, any>) {}
+
+  #isNot = false
+
+  #conds: ExpressionWrapper<any, any, any>[] = []
+  protected addCond(cond: ExpressionWrapper<any, any, any>): void {
+    this.#conds.push(cond)
+  }
+  get cond(): ExpressionWrapper<any, any, any> {
+    if (this.#isNot) {
+      return this.eb.not(this.eb.and(this.#conds))
+    }
+
+    return this.eb.and(this.#conds)
+  }
+  or(left: ISpecification<T, ISpecVisitor>, right: ISpecification<T, ISpecVisitor>): this {
+    const Visitor = Object.getPrototypeOf(this).constructor
+
+    const lv = new Visitor(this.eb)
+    left.accept(lv)
+
+    const rv = new Visitor(this.eb)
+    right.accept(rv)
+
+    const cond = this.eb.or([lv.cond, rv.cond])
+    this.addCond(cond)
+
+    return this
+  }
+
+  not(): this {
+    this.#isNot = true
+    return this
+  }
+}

packages/persistence/src/abstract-qb.visitor.ts

@@ -1 +1 @@
-export * from './record.repository'
+export * from './record.query-repository'

packages/persistence/src/record/index.ts

@@ -1,25 +1,9 @@
-import type { ISpecification, ISpecVisitor } from '@undb/domain'
-import type { IRecordVisitor } from '@undb/table'
-import type { StringEqual } from '@undb/table/src/modules/schema/fields/variants/string-field/string-field-value.specification'
-import type { ExpressionBuilder, ExpressionWrapper } from 'kysely'
+import type { IRecordVisitor, RecordDO, StringEqual } from '@undb/table'
+import { AbstractQBVisitor } from '../abstract-qb.visitor'
 
-export class RecordFilterVisitor implements IRecordVisitor {
-  constructor(private readonly eb: ExpressionBuilder<any, any>) {}
-
-  #conds: ExpressionWrapper<any, any, any>[] = []
-  protected addCond(cond: ExpressionWrapper<any, any, any>): void {
-    this.#conds.push(cond)
-  }
-  get cond(): ExpressionWrapper<any, any, any> {
-    return this.eb.and(this.#conds)
-  }
+export class RecordFilterVisitor extends AbstractQBVisitor<RecordDO> implements IRecordVisitor {
   stringEqual(spec: StringEqual): void {
-    this.addCond(this.eb.eb(spec.fieldId.value, '=', spec.values.value))
-  }
-  or(left: ISpecification<any, ISpecVisitor>, right: ISpecification<any, ISpecVisitor>): this {
-    throw new Error('Method not implemented.')
-  }
-  not(): this {
-    throw new Error('Method not implemented.')
+    const cond = this.eb.eb(spec.fieldId.value, '=', spec.values.value)
+    this.addCond(cond)
   }
 }

packages/persistence/src/record/record.filter-visitor.ts

@@ -0,0 +1,20 @@
+import { singleton } from '@undb/di'
+import type { Mapper } from '@undb/domain'
+import type { IRecordDTO, RecordDO } from '@undb/table'
+
+@singleton()
+export class RecordMapper implements Mapper<RecordDO, any, IRecordDTO> {
+  toDo(entity: any): RecordDO {
+    throw new Error('Method not implemented.')
+  }
+  toEntity(domain: RecordDO) {
+    throw new Error('Method not implemented.')
+  }
+  toDTO(entity: any): IRecordDTO {
+    const { id, ...rest } = entity
+    return {
+      id: entity.id,
+      values: rest,
+    }
+  }
+}

packages/persistence/src/record/record.mapper.ts

@@ -0,0 +1,37 @@
+import { inject, singleton } from '@undb/di'
+import type { Option } from '@undb/domain'
+import type { IRecordQueryRepository, IRecordsDTO, Query, TableDo } from '@undb/table'
+import type { IQueryBuilder } from '../qb'
+import { injectQueryBuilder } from '../qb.provider'
+import { UnderlyingTable } from '../underlying/underlying-table'
+import { RecordFilterVisitor } from './record.filter-visitor'
+import { RecordMapper } from './record.mapper'
+
+@singleton()
+export class RecordQueryRepository implements IRecordQueryRepository {
+  constructor(
+    @injectQueryBuilder()
+    private readonly qb: IQueryBuilder,
+    @inject(RecordMapper)
+    private readonly mapper: RecordMapper
+  ) {}
+
+  async find(table: TableDo, query: Option<Query>): Promise<IRecordsDTO> {
+    const t = new UnderlyingTable(table)
+    const result = await this.qb
+      .selectFrom(t.name)
+      // TODO: select spec
+      .selectAll()
+      .where((eb) => {
+        const spec = query.into(null)?.filter
+        const visitor = new RecordFilterVisitor(eb)
+        if (spec?.isSome()) {
+          spec.unwrap().accept(visitor)
+        }
+        return visitor.cond
+      })
+      .execute()
+
+    return result.map((r) => this.mapper.toDTO(r))
+  }
+}

packages/persistence/src/record/record.query-repository.ts

@@ -0,0 +1,16 @@
+import { Query, type QueryProps } from '@undb/domain'
+import { getRecordsDTO } from '@undb/table'
+import { z } from 'zod'
+
+export const getRecordsQuery = getRecordsDTO
+
+export type IGetRecordsQuery = z.infer<typeof getRecordsQuery>
+
+export class GetRecordsQuery extends Query implements IGetRecordsQuery {
+  public readonly tableId: string
+
+  constructor(props: QueryProps<IGetRecordsQuery>) {
+    super()
+    this.tableId = props.tableId
+  }
+}

packages/persistence/src/record/record.repository.ts

@@ -1,2 +1,3 @@
+export * from './get-records.query'
 export * from './get-table.query'
 export * from './get-tables.query'

packages/queries/src/get-records.query.ts

@@ -0,0 +1,23 @@
+import { queryHandler } from '@undb/cqrs'
+import { singleton } from '@undb/di'
+import type { IQueryHandler } from '@undb/domain'
+import { createLogger } from '@undb/logger'
+import { GetRecordsQuery, type IGetRecordsQuery } from '@undb/queries'
+import { injectRecordsQueryService, type IRecordsDTO, type IRecordsQueryService } from '@undb/table'
+
+@queryHandler(GetRecordsQuery)
+@singleton()
+export class GetRecordsQueryHandler implements IQueryHandler<IGetRecordsQuery, any> {
+  private readonly logger = createLogger(GetRecordsQueryHandler.name)
+
+  constructor(
+    @injectRecordsQueryService()
+    private readonly svc: IRecordsQueryService
+  ) {}
+
+  async execute(query: IGetRecordsQuery): Promise<IRecordsDTO> {
+    this.logger.debug(query, 'get records query executed')
+
+    return this.svc.getRecords(query)
+  }
+}

packages/queries/src/index.ts

@@ -1,4 +1,5 @@
+import { GetRecordsQueryHandler } from './get-records.query-handler'
 import { GetTableQueryHandler } from './get-table.query-handler'
 import { GetTablesQueryHandler } from './get-tables.query-handler'
 
-export const queryHandlers = [GetTablesQueryHandler, GetTableQueryHandler]
+export const queryHandlers = [GetTablesQueryHandler, GetTableQueryHandler, GetRecordsQueryHandler]

packages/query-handlers/src/handlers/get-records.query-handler.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod'
+import { tableId } from '../../../table-id.vo'
+
+export const getRecordsDTO = z.object({
+  tableId: tableId,
+})
+
+export type IGetRecordsDTO = z.infer<typeof getRecordsDTO>

packages/query-handlers/src/handlers/index.ts

@@ -0,0 +1,2 @@
+export * from './get-records.dto'
+export * from './records.dto'

packages/table/src/modules/records/dto/get-records.dto.ts

@@ -0,0 +1,6 @@
+import type { z } from 'zod'
+import { recordDTO } from '../record/dto'
+
+export const recordsDTO = recordDTO.array()
+
+export type IRecordsDTO = z.infer<typeof recordsDTO>

packages/table/src/modules/records/dto/index.ts

@@ -1,2 +1,4 @@
+export * from './dto'
 export * from './record'
 export * from './records.vo'
+export * from './services'

packages/table/src/modules/records/dto/records.dto.ts

@@ -0,0 +1 @@
+export * from './record.dto'

packages/table/src/modules/records/index.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod'
+import { recordId } from '../record-id.vo'
+import { recordValues } from '../record-values.vo'
+
+export const recordDTO = z.object({
+  id: recordId,
+  values: recordValues,
+})
+
+export type IRecordDTO = z.infer<typeof recordDTO>

packages/table/src/modules/records/record/dto/index.ts

@@ -1,3 +1,4 @@
+export * from './dto'
 export * from './record-id.vo'
 export * from './record-values.vo'
 export * from './record-visitor.interface'

packages/table/src/modules/records/record/dto/record.dto.ts

@@ -1,6 +1,9 @@
 import { Option, ValueObject } from '@undb/domain'
+import { z } from 'zod'
 import type { FieldValue } from '../../schema'
-import type { FieldId, IFieldId } from '../../schema/fields/field-id.vo'
+import { fieldId, type FieldId, type IFieldId } from '../../schema/fields/field-id.vo'
+
+export const recordValues = z.record(fieldId, z.any())
 
 export class RecordValuesVO extends ValueObject {
   #map: Map<IFieldId, FieldValue>

packages/table/src/modules/records/record/index.ts

@@ -1,4 +1,4 @@
 import { inject } from '@undb/di'
 
-export const RECORD_REPOSITORY = Symbol('RECORD_REPOSITORY')
-export const injectRecordRepository = () => inject(RECORD_REPOSITORY)
+export const RECORD_QUERY_REPOSITORY = Symbol('RECORD_QUERY_REPOSITORY')
+export const injectRecordQueryRepository = () => inject(RECORD_QUERY_REPOSITORY)

packages/table/src/modules/records/record/record-values.vo.ts

@@ -1,6 +1,13 @@
 import type { Option } from '@undb/domain'
+import type { TableDo } from '../../../table.do'
+import type { IRecordsDTO } from '../dto/records.dto'
 import type { RecordComositeSpecification } from './record.composite-specification'
 
-export interface IRecordRepository {
-  find(spec: Option<RecordComositeSpecification>): void
+export interface Query {
+  select: Option<RecordComositeSpecification>
+  filter: Option<RecordComositeSpecification>
+}
+
+export interface IRecordQueryRepository {
+  find(table: TableDo, query: Option<Query>): Promise<IRecordsDTO>
 }

packages/table/src/modules/records/record/record.repository.provider.ts

@@ -0,0 +1,2 @@
+export * from './records.query-service'
+export * from './records.query-service.provider'

packages/table/src/modules/records/record/record.repository.ts

@@ -0,0 +1,11 @@
+import { None } from '@undb/domain'
+import { TableIdVo } from '../../../../table-id.vo'
+import type { IGetRecordsDTO, IRecordsDTO } from '../../dto'
+import type { RecordsQueryService } from '../records.query-service'
+
+export async function getRecords(this: RecordsQueryService, dto: IGetRecordsDTO): Promise<IRecordsDTO> {
+  const tableId = new TableIdVo(dto.tableId)
+  const table = (await this.tableRepository.findOneById(tableId)).expect('Table not found')
+
+  return this.repo.find(table, None)
+}

packages/table/src/modules/records/services/index.ts

@@ -0,0 +1,6 @@
+import { container, inject } from '@undb/di'
+import { RecordsQueryService } from './records.query-service'
+
+export const RECORDS_QUERY_SERVICE = Symbol.for('RECORDS_QUERY_SERVICE')
+export const injectRecordsQueryService = () => inject(RECORDS_QUERY_SERVICE)
+container.register(RECORDS_QUERY_SERVICE, { useClass: RecordsQueryService })