@cuboapp/api-backend 1.0.29 → 1.0.31

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cuboapp/api-backend",
-  "version": "1.0.29",
+  "version": "1.0.31",
   "description": "Backend Api for CuboApp",
   "main": "src/index.ts",
   "repository": "git@github.com:cuboapp/api-backend.git",
@@ -8,12 +8,13 @@
   "license": "MIT",
   "type": "module",
   "dependencies": {
-    "@cuboapp/constants": "2.0.7",
-    "@cuboapp/crdt": "1.0.6",
+    "@cuboapp/constants": "2.0.8",
+    "@cuboapp/crdt": "1.0.9",
     "@cuboapp/database": "1.0.4",
-    "@cuboapp/types": "2.0.12",
+    "@cuboapp/types": "2.0.13",
     "@cuboapp/utils": "1.0.10",
-    "@cuboapp/ws": "1.0.5",
+    "@cuboapp/ws": "1.0.6",
+    "mime-types": "^3.0.2",
     "pg": "^8.17.2",
     "yjs": "^13.6.29"
   },

package/src/helpers/index.ts

@@ -16,6 +16,7 @@ import { CuboBackendApiDbConnectionType, CuboCrudFindQuery, CuboCrudRequest } fr
 import { ApiHelpersConvert } from './convert'
 import { ApiHelpersData } from './data'
 
+import { cloneDeep } from '@cuboapp/utils'
 import { ApiHelpersWithes } from './withes'
 
 export class ApiHelpers<T extends CuboApiEntitiesMap<T>, A> {
@@ -316,13 +317,17 @@ export class ApiHelpers<T extends CuboApiEntitiesMap<T>, A> {
     }
 
     this.connecting[type] = new Promise(async (success) => {
-      const { iaas, pk_key, pk_type, ...config } = this.api.options.db.options
+      if (this.api.options.db.connection) {
+        this.connections[type] = this.api.options.db.connection
+      } else {
+        const { iaas, pk_key, pk_type, ...config } = this.api.options.db.options
 
-      this.connections[type] = createDatabase(config, JSON.parse(JSON.stringify({ iaas, pk_key, pk_type })))
-      await this.connections[type].connect()
+        this.connections[type] = createDatabase(config, JSON.parse(JSON.stringify({ iaas, pk_key, pk_type })))
+        await this.connections[type].connect()
 
-      if (config.dialect === 'postgres' && config.schema) {
-        await this.connections[type].connection.query(`SET schema '${config.schema}';`)
+        if (config.dialect === 'postgres' && config.schema) {
+          await this.connections[type].connection.query(`SET schema '${config.schema}';`)
+        }
       }
 
       success(this.connections[type])
@@ -353,17 +358,18 @@ export class ApiHelpers<T extends CuboApiEntitiesMap<T>, A> {
     queryDto?: Partial<CuboCrudFindQuery>,
     isCount?: boolean
   ): Promise<Partial<CuboCrudFindQuery>> {
-    const withes = queryDto?.withes !== undefined ? queryDto.withes : []
-    const selects = queryDto?.selects !== undefined ? queryDto.selects : []
-    const joins = queryDto?.joins !== undefined ? queryDto.joins : []
-    const conditions = queryDto?.conditions !== undefined ? queryDto.conditions : []
-    const havings = queryDto?.havings !== undefined ? queryDto.havings : []
-    const sorts = queryDto?.sorts !== undefined ? queryDto.sorts : []
-    const replacements = queryDto?.replacements !== undefined ? queryDto?.replacements : {}
-    const groupBy = queryDto?.groupBy !== undefined ? queryDto?.groupBy : undefined
-    const withCrdt = queryDto?.withCrdt !== undefined ? queryDto?.withCrdt : false
-
-    const { sort, limit: _limit, page, with: _withes, ...query } = req.query || {}
+    const dto: Partial<CuboCrudFindQuery> = cloneDeep(queryDto || {})
+
+    const withes = dto.withes ?? []
+    const selects = dto.selects ?? []
+    const joins = dto.joins ?? []
+    const conditions = dto.conditions ?? []
+    const havings = dto.havings ?? []
+    const sorts = dto.sorts ?? []
+    const replacements = dto.replacements ?? {}
+    const groupBy = dto.groupBy ?? undefined
+
+    const { sort, limit: _limit, page, with: _withes, ...query } = cloneDeep(req.query || {})
 
     // plain conditions (nested are in withes.ts)
     for (const key in query || {}) {
@@ -374,6 +380,7 @@ export class ApiHelpers<T extends CuboApiEntitiesMap<T>, A> {
         const defaultField = CUBO_CRUD_DEFAULT_FIELDS.find((f) => f.alias === parts[0])
 
         if (!conditionField && !defaultField) {
+          console.log(entity.alias, entity.fields)
           throw new Error('condition field "' + parts[0] + '" not found in entity "' + entity.alias + '"')
         }
 

package/src/index.ts

@@ -4,6 +4,7 @@ import { cloneDeep } from '@cuboapp/utils'
 
 import { ApiHelpers } from './helpers'
 import { CuboBackendApiAuth, CuboBackendApiOptions, CuboCrudGetManyResponse, CuboCrudMethodOptions, CuboCrudRequest } from './types'
+import { CuboS3UploadFunctionOptions, CuboS3UploadFunctionResult, uploadToS3 } from './s3'
 
 export class CuboBackendApi<T extends CuboApiEntitiesMap<T>, A extends unknown> {
   constructor(public options: CuboBackendApiOptions<T, A>) {}
@@ -121,6 +122,10 @@ export class CuboBackendApi<T extends CuboApiEntitiesMap<T>, A extends unknown>
     }
   }
 
+  public async uploadToS3(buffer: Buffer, opts: CuboS3UploadFunctionOptions): Promise<CuboS3UploadFunctionResult> {
+    return uploadToS3(buffer, opts)
+  }
+  
   private async getEntity(entityAlias: Extract<keyof T, string>) {
     const entity = await this.helpers.getEntityByAlias(entityAlias)
     if (!entity) {

package/src/s3/index.ts

@@ -0,0 +1,104 @@
+import { CuboS3UploadFunction } from './types'
+import {
+  defaultFileName,
+  encodeRfc3986,
+  encodeS3Key,
+  toAmzDate,
+  sha256Hex,
+  normalizeHeaderValue,
+  getSignatureKey,
+  hmacHex,
+  buildS3Key
+} from './utils'
+
+/**
+ * Upload buffer to S3 using PUT Object.
+ * - Uses path-style URL: {endpoint}/{bucket}/{key}
+ */
+export const uploadToS3: CuboS3UploadFunction = async (buffer, opts) => {
+  const { bucket, region, endpoint, access_key, secret } = opts.s3
+  const mimeType = opts.mime_type || 'application/octet-stream'
+
+  const baseName = opts.file_name || defaultFileName(mimeType)
+  const fileName = buildS3Key(baseName, opts.s3.folder)
+
+  const ep = new URL(endpoint)
+  const host = ep.host
+
+  const canonicalUri = `/${encodeRfc3986(bucket)}/${encodeS3Key(fileName)}`
+  const url = new URL(`${ep.origin}${canonicalUri}`)
+
+  const method = 'PUT'
+  const service = 's3'
+
+  const amzDate = toAmzDate(new Date()) // YYYYMMDDTHHMMSSZ
+  const dateStamp = amzDate.slice(0, 8) // YYYYMMDD
+
+  const payloadHash = sha256Hex(buffer)
+
+  const headers: Record<string, string> = {
+    host,
+    'content-type': mimeType,
+    'x-amz-content-sha256': payloadHash,
+    'x-amz-date': amzDate
+  }
+
+  const signedHeaders = Object.keys(headers)
+    .map((h) => h.toLowerCase())
+    .sort()
+    .join(';')
+
+  const canonicalHeaders = Object.keys(headers)
+    .map((k) => k.toLowerCase())
+    .sort()
+    .map((k) => `${k}:${normalizeHeaderValue(headers[k])}\n`)
+    .join('')
+
+  const canonicalQueryString = ''
+
+  const canonicalRequest =
+    `${method}\n` + `${canonicalUri}\n` + `${canonicalQueryString}\n` + `${canonicalHeaders}\n` + `${signedHeaders}\n` + `${payloadHash}`
+
+  const algorithm = 'AWS4-HMAC-SHA256'
+  const credentialScope = `${dateStamp}/${region}/${service}/aws4_request`
+  const stringToSign = `${algorithm}\n` + `${amzDate}\n` + `${credentialScope}\n` + `${sha256Hex(Buffer.from(canonicalRequest, 'utf8'))}`
+
+  const signingKey = getSignatureKey(secret, dateStamp, region, service)
+  const signature = hmacHex(signingKey, stringToSign)
+
+  const authorization =
+    `${algorithm} ` + `Credential=${access_key}/${credentialScope}, ` + `SignedHeaders=${signedHeaders}, ` + `Signature=${signature}`
+
+  try {
+    const res = await fetch(url.toString(), {
+      method,
+      headers: {
+        ...headers,
+        Authorization: authorization
+      },
+      body: buffer as any
+    })
+
+    if (!res.ok) {
+      const text = await res.text()
+      throw {
+        code: res.status,
+        error: res.statusText,
+        text
+      }
+    }
+
+    const resUrl = res.url || url.toString()
+
+    return { fileName: baseName, url: resUrl }
+  } catch (error) {
+    console.log('error')
+    throw {
+      code: 500,
+      text: error
+    }
+  }
+}
+
+export * from './types'
+export * from './utils'

package/src/s3/types/index.ts

@@ -0,0 +1,19 @@
+export type CuboS3UploadFunctionOptions = {
+  file_name?: string
+  mime_type: string
+  s3: {
+    bucket: string
+    region: string
+    endpoint: string
+    access_key: string
+    secret: string
+    folder?: string
+  }
+}
+
+export type CuboS3UploadFunctionResult = {
+  fileName: string
+  url: string
+}
+
+export type CuboS3UploadFunction = (buffer: Buffer, opts: CuboS3UploadFunctionOptions) => Promise<CuboS3UploadFunctionResult>

package/src/s3/utils/index.ts

@@ -0,0 +1,74 @@
+import { uuid } from '@cuboapp/utils'
+import crypto from 'node:crypto'
+import { extension } from 'mime-types'
+
+export const defaultFileName = (mimeType: string) => {
+  const ext = extension(mimeType)
+  const id = uuid()
+  return `${id}.${ext}`
+}
+
+export const normalizeFileName = (name: string) => {
+  return name.replace(/^\/+/, '')
+}
+
+export const toAmzDate = (d: Date) => {
+  // YYYYMMDDTHHMMSSZ
+  const pad = (n: number) => String(n).padStart(2, '0')
+  return (
+    d.getUTCFullYear() +
+    pad(d.getUTCMonth() + 1) +
+    pad(d.getUTCDate()) +
+    'T' +
+    pad(d.getUTCHours()) +
+    pad(d.getUTCMinutes()) +
+    pad(d.getUTCSeconds()) +
+    'Z'
+  )
+}
+
+export const sha256Hex = (data: Buffer) => {
+  return crypto.createHash('sha256').update(data).digest('hex')
+}
+
+export const hmac = (key: Buffer | string, data: string) => {
+  return crypto.createHmac('sha256', key).update(data, 'utf8').digest()
+}
+
+export const hmacHex = (key: Buffer | string, data: string) => {
+  return crypto.createHmac('sha256', key).update(data, 'utf8').digest('hex')
+}
+
+export const getSignatureKey = (secretKey: string, dateStamp: string, region: string, service: string) => {
+  const kDate = hmac('AWS4' + secretKey, dateStamp)
+  const kRegion = hmac(kDate, region)
+  const kService = hmac(kRegion, service)
+  const kSigning = hmac(kService, 'aws4_request')
+  return kSigning
+}
+
+export const normalizeHeaderValue = (v: string) => {
+  return v.trim().replace(/\s+/g, ' ')
+}
+
+export const encodeRfc3986 = (str: string) => {
+  return encodeURIComponent(str).replace(/[!'()*]/g, (c) => '%' + c.charCodeAt(0).toString(16).toUpperCase())
+}
+
+export const encodeS3Key = (key: string) => {
+  return key
+    .split('/')
+    .map((seg) => encodeRfc3986(seg))
+    .join('/')
+}
+
+export const buildS3Key = (fileName: string, folder?: string) => {
+  const cleanFile = normalizeFileName(fileName)
+
+  if (!folder) {
+    return cleanFile
+  }
+
+  const cleanFolder = folder.replace(/^\/+|\/+$/g, '')
+  return `${cleanFolder}/${cleanFile}`
+}