@cuboapp/api-backend 1.0.0

package/src/types/augmentation.ts

@@ -0,0 +1,29 @@
+import { CuboApiEntitiesMap } from '@cuboapp/types'
+
+import { CuboCrudGetManyResponse, CuboCrudRequest } from './basic'
+import { CuboCrudMethodOptions, CuboCrudQueryOptions } from './db'
+
+export type CuboCrudAugmentationsStore<T extends CuboApiEntitiesMap<T>> = {
+  [K in Extract<keyof T, string>]?: CuboCrudAugmentationInstance<T[K]>
+}
+
+export interface CuboCrudAugmentationInstance<T = unknown> {
+  beforeGetMany?: (req: CuboCrudRequest, opts?: CuboCrudMethodOptions) => Promise<CuboCrudQueryOptions>
+  afterGetMany?: (
+    result: CuboCrudGetManyResponse<T>,
+    req: CuboCrudRequest,
+    opts?: CuboCrudMethodOptions
+  ) => Promise<CuboCrudGetManyResponse<T>>
+
+  beforeGetOne?: (req: CuboCrudRequest, opts?: CuboCrudMethodOptions) => Promise<CuboCrudQueryOptions>
+  afterGetOne?: (result: T, req: CuboCrudRequest, opts?: CuboCrudMethodOptions) => Promise<T | undefined>
+
+  beforeCreate?: (req: CuboCrudRequest, opts?: CuboCrudMethodOptions) => Promise<CuboCrudQueryOptions>
+  afterCreate?: (result: T, req: CuboCrudRequest, opts?: CuboCrudMethodOptions) => Promise<T>
+
+  beforeUpdate?: (req: CuboCrudRequest, opts?: CuboCrudMethodOptions) => Promise<CuboCrudQueryOptions>
+  afterUpdate?: (result: T, req: CuboCrudRequest, opts?: CuboCrudMethodOptions) => Promise<T>
+
+  beforeDelete?: (req: CuboCrudRequest, opts?: CuboCrudMethodOptions) => Promise<CuboCrudQueryOptions>
+  afterDelete?: (result: T, req: CuboCrudRequest, opts?: CuboCrudMethodOptions) => Promise<boolean>
+}

package/src/types/basic.ts

@@ -0,0 +1,59 @@
+import { CuboEntity, CuboEntityField } from '@cuboapp/types'
+import { type Transaction } from 'sequelize'
+
+export type CuboCrudWith = {
+  entity: CuboEntity | { id: undefined; alias: string; fields: CuboEntityField[] }
+  key: string
+  full_key: string
+  table_name: string
+}
+
+export type CuboCrudQueryDefaults = {
+  query?: string
+  sort?: string
+  limit?: number
+  page?: number
+}
+
+export type CuboCrudRequest = {
+  headers?: Record<string, any>
+  query?: Record<string, any>
+  params?: Record<string, any>
+  body?: any
+}
+
+export type CuboCrudOptions = {
+  user_id?: number
+  transaction?: Transaction
+}
+
+export type CuboCrudDto = {
+  entity: CuboEntity
+  request: CuboCrudRequest
+  options: CuboCrudOptions
+  state: any
+}
+
+export type CuboCrudFindQuery = {
+  selects: string[]
+  conditions: string[]
+  replacements: Record<string, any>
+  sorts: string[]
+  offset: number
+  limit: number
+
+  joins: string[]
+  withes: CuboCrudWith[]
+
+  withDeleted?: boolean
+  is_count: boolean
+  sql: string
+}
+
+export type CuboCrudGetManyResponse<T, E extends object = object> = {
+  rows: T[]
+  totals: {
+    count: number
+  }
+  extra?: E
+}

package/src/types/db.ts

@@ -0,0 +1,24 @@
+import { type Transaction } from 'sequelize'
+
+export type CuboCrudQueryOptions = {
+  selects?: string[]
+  conditions?: string[]
+  replacements?: Record<string, any>
+  joins?: string[]
+  withes?: string[]
+  sorts?: string[]
+  withDeleted?: boolean
+
+  extra?: any
+}
+
+export type CuboCrudMethodOptions<E extends object = {}> = {
+  transaction?: Transaction
+  user_id?: number
+  extra?: any
+  excludeHooks?: ('beforeGetMany' | 'beforeGetOne' | 'afterCreate' | 'afterUpdate' | 'afterDelete' | 'afterGetMany' | 'afterGetOne')[]
+
+  log?: boolean
+
+  queryOptions?: CuboCrudQueryOptions
+} & E

package/src/types/index.ts

@@ -0,0 +1,3 @@
+export * from './augmentation'
+export * from './basic'
+export * from './db'

package/src/utils/index.ts

@@ -0,0 +1,128 @@
+import { QueryTypes, Sequelize, Transaction } from 'sequelize'
+
+export function dbPrepareUpdateQueryString(obj: Record<string, any>) {
+  const keys: string[] = []
+  const replacements: Record<string, any> = {}
+
+  for (const key in obj) {
+    const value = obj[key]
+
+    keys.push(`${key} = :${key}`)
+
+    let val = null
+
+    if (typeof value === 'string') {
+      val = !!value ? value : null
+    } else if (typeof value === 'number') {
+      val = !isNaN(value) ? value : null
+    } else if (typeof value === 'boolean') {
+      val = value
+    } else if (Array.isArray(value) || typeof value === 'object') {
+      val = value ? JSON.stringify(value) : null
+    }
+
+    replacements[key] = val
+  }
+
+  return { query: keys.join(', '), replacements }
+}
+
+export function dbPrepareInsertQueryString(obj: Record<string, any>) {
+  const values: string[] = []
+  const replacements: Record<string, any> = {}
+
+  for (const key in obj) {
+    const value = obj[key]
+
+    values.push(`:${key}`)
+
+    let val = null
+
+    if (typeof value === 'string') {
+      val = !!value ? value : null
+    } else if (typeof value === 'number') {
+      val = !isNaN(value) ? value : null
+    } else if (typeof value === 'boolean') {
+      val = value
+    } else if (Array.isArray(value) || typeof value === 'object') {
+      val = value ? JSON.stringify(value) : null
+    }
+
+    replacements[key] = val
+  }
+
+  return { keys: Object.keys(obj).join(', '), values: values.join(','), replacements }
+}
+
+export async function dbCreate(
+  db: Sequelize,
+  table: string,
+  arInsert: any,
+  opts?: { log?: boolean; transaction?: Transaction }
+): Promise<{ id: number }> {
+  if (Object.keys(arInsert).length > 0) {
+    const dialect = db.getDialect()
+
+    const { keys, values, replacements } = dbPrepareInsertQueryString(arInsert)
+
+    let sql = ''
+
+    switch (dialect) {
+      case 'postgres':
+        sql = `insert into ${table} (${keys}) values (${values}) returning id`
+        break
+      case 'mysql':
+        sql = `insert into ${table} (${keys}) values (${values})`
+        break
+      default:
+        throw ''
+    }
+
+    if (opts?.log) {
+      console.warn(`QUERY: ${sql} [${JSON.stringify(replacements)}]`)
+    }
+
+    return db
+      .query(sql, {
+        type: QueryTypes.INSERT,
+        replacements,
+        transaction: opts?.transaction
+      })
+      .then((res: any) => {
+        switch (dialect) {
+          case 'postgres':
+            return { id: +res?.[0]?.[0].id }
+          case 'mysql':
+            return { id: +res[0] }
+        }
+      })
+  }
+
+  throw new Error('QUERY: db create array empty')
+}
+
+export async function dbUpdate(
+  db: Sequelize,
+  table: string,
+  where: string,
+  replacements: Record<string, any>,
+  arUpdate: any,
+  opts?: { log?: boolean; transaction?: Transaction }
+) {
+  if (Object.keys(arUpdate).length > 0) {
+    const prepared = dbPrepareUpdateQueryString(arUpdate)
+
+    if (opts?.log) {
+      console.warn(`QUERY: update ${table} set ${prepared.query} where ${where} [${JSON.stringify(replacements)}]`)
+    }
+
+    await db.query(`update ${table} set ${prepared.query} where ${where}`, {
+      type: QueryTypes.UPDATE,
+      replacements: {
+        ...(replacements || {}),
+        ...(prepared.replacements || {})
+      },
+      transaction: opts?.transaction
+    })
+  }
+}

package/tsconfig.build.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": ["node_modules", "test", "dist", "**/*spec.ts"]
+}

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "declaration": true,
+    "removeComments": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "allowSyntheticDefaultImports": true,
+    "target": "ES2021",
+    "sourceMap": true,
+    "outDir": "./dist",
+    "baseUrl": "./",
+    "incremental": true,
+    "skipLibCheck": true,
+    "paths": {
+      "@/*": ["src/*"]
+    }
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}