rajt 0.0.58 → 0.0.59

package/src/auth/auth.ts

@@ -1,33 +0,0 @@
-import { Authnz } from './authnz'
-import { Token } from './token'
-
-export class Auth {
-  static #u: Authnz<any> | null = null
-
-  static resolve() {
-    this.#u = Authnz.fromToken(Token.fromRequest())
-  }
-
-  static get user() {
-    return this.#u ? this.#u?.data : null
-  }
-
-  static can(...abilities: string[]): boolean {
-    return this.#u ? this.#u.can(...abilities) : false
-  }
-
-  static cant(...abilities: string[]): boolean {
-    return !this.can(...abilities)
-  }
-
-  static hasRole(...roles: string[]): boolean {
-    return this.#u ? this.#u.hasRole(...roles) : false
-  }
-
-  static has(prop: string, value: any = null): boolean {
-    return this.#u ? this.#u.has(prop, value) : false
-  }
-  static hasValue(prop: string, value: any = null): boolean {
-    return this.has(prop, value)
-  }
-}

package/src/dynamodb/client.ts

@@ -1,125 +0,0 @@
-import { DynamoDBClient } from '@aws-sdk/client-dynamodb'
-import {
-  DynamoDBDocumentClient,
-
-  BatchGetCommand,
-  BatchWriteCommand,
-
-  DeleteCommand,
-  GetCommand,
-  PutCommand,
-  QueryCommand,
-  ScanCommand,
-  UpdateCommand,
-
-  ScanCommandInput,
-  QueryCommandInput,
-  UpdateCommandInput,
-
-  BatchGetCommandInput,
-  BatchWriteCommandInput,
-} from '@aws-sdk/lib-dynamodb'
-import type { NativeAttributeValue } from '@aws-sdk/util-dynamodb'
-import AbstractModel from './model'
-import { Keys, KeySchema } from './types'
-
-const client = new DynamoDBClient(process.env?.AWS_SAM_LOCAL ? {
-  region: process.env.AWS_REGION || 'us-east-1',
-  endpoint: process.env.AWS_ENDPOINT_URL || undefined,
-  credentials: {
-    accessKeyId: process.env.AWS_ACCESS_KEY_ID || 'DUMMYIDEXAMPLE',
-    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY || 'DUMMYEXAMPLEKEY',
-  },
-} : {})
-
-export const DocumentClient = DynamoDBDocumentClient.from(client)
-
-export class Dynamodb {
-  static model<T extends object>(cls: new (...args: any[]) => T) {
-    return new AbstractModel<T>(cls)
-  }
-
-  static raw() {
-    return RawClient
-  }
-}
-
-export class RawClient {
-  static async get(TableName: string, key: Keys | Record<string, string>, sk?: string) {
-    return DocumentClient.send(new GetCommand({ TableName, Key: this.key(key, sk) }))
-  }
-
-  static async scan(TableName: string, filters: Omit<ScanCommandInput, 'TableName'>) {
-    return DocumentClient.send(new ScanCommand({ ...filters, TableName }))
-  }
-
-  static async query(TableName: string, filters: Omit<QueryCommandInput, 'TableName'>) {
-    return DocumentClient.send(new QueryCommand({ ...filters, TableName }))
-  }
-
-  static async put(TableName: string, Item: Record<string, NativeAttributeValue>) {
-    return DocumentClient.send(new PutCommand({ TableName, Item }))
-  }
-
-  static async update(
-    TableName: string,
-    filters: Omit<UpdateCommandInput, 'TableName' | 'Key'>,
-    key: Keys | Record<string, string>,
-    sk?: string
-  ) {
-    return DocumentClient.send(new UpdateCommand({
-      ...filters, TableName, Key: this.key(key, sk),
-    }))
-  }
-
-  static async delete(TableName: string, key: Keys | Record<string, string>, sk?: string) {
-    return DocumentClient.send(new DeleteCommand({ TableName, Key: this.key(key, sk) }))
-  }
-
-  static async batchGet(batch: BatchGetCommandInput) {
-    return DocumentClient.send(new BatchGetCommand(batch))
-  }
-
-  static async batchWrite(batch: BatchWriteCommandInput) {
-    return DocumentClient.send(new BatchWriteCommand(batch))
-  }
-
-  static key(
-    key: Keys | Record<string, string>,
-    sk?: string,
-    schema?: KeySchema,
-    defaultSK?: string,
-  ) {
-    let pk: string
-    let skValue: string | undefined
-
-    if (Array.isArray(key)) {
-      pk = key[0]
-      skValue = key[1] ?? sk
-    } else if (typeof key == 'object' && key != null) {
-      return key
-    } else {
-      pk = key
-      skValue = sk
-    }
-
-    if (!schema) {
-      const keys = {PK: pk}
-      // @ts-ignore
-      if (skValue) keys.SK = skValue
-      return keys
-    }
-
-    const keys = { [schema.PK]: pk }
-
-    if (schema?.SK) {
-      if (skValue) {
-        keys[schema.SK] = skValue
-      } else if (defaultSK) {
-        keys[schema.SK] = defaultSK
-      }
-    }
-
-    return keys
-  }
-}

package/src/dynamodb/compact.ts

@@ -1,205 +0,0 @@
-import { getLength } from 't0n'
-import { isArraySchema } from './schema'
-import type { SchemaStructure } from './types'
-
-export default class Compact {
-  static #typeRegex: RegExp
-  static #reverseTypeRegex: RegExp
-  static #reverseTypeMap: Record<string, string>
-  static #typeMap: Record<string, string> = {
-    // Boolean
-    'true': 'T',
-    'false': 'F',
-    // Null
-    'null': 'N',
-    // Array
-    '[]': 'A',
-    '["0"]': 'A0',
-    '["1"]': 'A1',
-    '["false"]': 'A2',
-    '["true"]': 'A3',
-    // Object
-    '{}': 'O',
-    // String
-    '""': 'S',
-    '"0"': 'S0',
-    '"1"': 'S1',
-    '"false"': 'S2',
-    '"true"': 'S3',
-  }
-
-  static {
-    const keys = []
-    const values = []
-    const reverseTypeMap: Record<string, string> = {}
-    for (const key in this.#typeMap) {
-      const val = this.#typeMap[key]
-      const k = key.replace(/"/g, "'")
-      keys.push(k)
-      values.push(val)
-
-      reverseTypeMap[val] = k
-      this.#typeMap[k] = val
-    }
-
-    this.#reverseTypeMap = reverseTypeMap
-    this.#typeRegex = this.#mapRegex(keys)
-    this.#reverseTypeRegex = this.#mapRegex(values)
-  }
-
-  static encode(obj: any, schema: SchemaStructure): string {
-    const seen: any[] = []
-
-    return this.#pack(
-      JSON.stringify(this.zip(obj, schema, seen))
-        .replace(/"\^(\d+)"/g, '^$1')
-        .replace(/"/g, '~TDQ~')
-        .replace(/'/g, '"')
-        .replace(/~TDQ~/g, "'")
-        .replace(/\\'/g, "^'")
-    )
-  }
-
-  static smartDecode<T = any>(val: any, schema: SchemaStructure): T {
-    if (!val) return val as T
-
-    if (Array.isArray(val)) // @ts-ignore
-      return val.map((i: {v: string}) => this.decode<T>(i?.V, schema)).filter(Boolean) as T
-
-    return val?.V ? this.decode<T>(val.V, schema) : val
-  }
-
-  static decode<T = any>(val: string, schema: SchemaStructure): T {
-    if (!val || typeof val !== 'string') return val as T
-
-    return this.withSchema(this.unzip(JSON.parse(
-      this.#unpack(val)
-        .replace(/"/g, '~TSQ~')
-        .replace(/'/g, '"')
-        .replace(/~TSQ~/g, "'")
-        .replace(/\^"/g, '\\"')
-        .replace(/(?<=[,{\[]|^)(\^\d+)(?=[,\]}[]|$)/g, '"$1"')
-    )), schema) as T
-  }
-
-  static zip(obj: any, schema: SchemaStructure, seen: any[]): any[] {
-    if (Array.isArray(obj))
-      return obj?.length ? obj.map(item => this.zip(item, schema, seen)) : []
-
-    if (this.#cantZip(obj)) return obj
-
-    return schema.map(key => {
-      if (typeof key == 'string')
-        return this.memo(obj[key], seen)
-
-      const mainKey = Object.keys(key)[0]
-      const subKeys = key[mainKey]
-      const val = obj[mainKey]
-
-      if (Array.isArray(val))
-        return val.map(item => this.zip(item, subKeys, seen))
-
-      return this.zip(val, subKeys, seen)
-    })
-  }
-
-  static unzip(val: any, seen: any[] = []): any[] {
-    if (Array.isArray(val))
-      return val?.length ? val.map(item => this.unzip(item, seen)) : []
-
-    const type = typeof val
-    const length = getLength(val, type)
-
-    if (this.#cantZip(val, type, length)) return val
-
-    if (type == 'object') {
-      for (const key in val)
-        val[key] = this.unzip(val[key], seen)
-
-      return val
-    }
-
-    if (type == 'string' && val.startsWith('^')) {
-      const item = seen[parseInt(val.slice(1), 10)]
-      return item ? item : val
-    }
-
-    seen.push(val)
-    return val
-  }
-
-  static withSchema(value: any[], keys: any[], deep = false): any {
-    if (!value || !Array.isArray(value))
-      return value
-
-    if (!deep && isArraySchema(keys))
-      return value?.length ? value.map(v => this.withSchema(v, keys, true)) : []
-
-    return Object.fromEntries(
-      keys.map((key, index) => this.entry(key, value[index])).filter(Boolean)
-    )
-  }
-
-  static entry(key: any, value: any): any {
-    if (!key) return undefined
-
-    if (typeof key == 'string')
-      return [key, value === undefined ? null : value]
-
-    const mainKey = Object.keys(key)[0]
-    const subKeys = key[mainKey]
-
-    if (Array.isArray(value)) {
-      if (value.length < 1)
-        return [mainKey, []]
-
-      return Array.isArray(value[0])
-        ? [mainKey, value.map(v => this.withSchema(v, subKeys))]
-        : [mainKey, this.withSchema(value, subKeys)]
-    }
-
-    return [mainKey, value === undefined ? null : value]
-  }
-
-  static memo(val: any, seen: any[]): any {
-    if (Array.isArray(val))
-      return val.map(item => this.memo(item, seen))
-
-    const type = typeof val
-    if (type == 'object' && val != null) {
-      for (const key in val)
-        val[key] = this.memo(val[key], seen)
-
-      return val
-    }
-
-    const length = getLength(val, type)
-    if (this.#cantZip(val, type, length)) return val
-
-    const index = seen.indexOf(val)
-    if (index !== -1)
-      return `^${index}`
-
-    seen.push(val)
-    return val
-  }
-
-  static #mapRegex(keys: string[]) {
-    keys = keys.sort((a, b) => b.length - a.length).map(k => k.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))
-    return new RegExp(`(?<![^\\s,\\[\\{:])(${keys.join('|')})(?![^\\s,\\]\\}:])`, 'g')
-  }
-
-  static #pack(val: string): string {
-    return val.replace(this.#typeRegex, match => this.#typeMap[match])
-  }
-
-  static #unpack(val: string): string {
-    return val.replace(this.#reverseTypeRegex, match => this.#reverseTypeMap[match])
-  }
-
-  static #cantZip(val: any, type: string = '', length: number = 0) {
-    if (!val || [null, true, false, 'true', 'false'].includes(val)) return true
-
-    return !type && !length ? false : type != 'object' && length < 2
-  }
-}

package/src/dynamodb/decorators.ts

@@ -1,126 +0,0 @@
-import pluralize from 'pluralize'
-import type { ModelMetadata, ModelOpts } from './types'
-
-export function getModelMetadata(target: Function | any): ModelMetadata {
-  if (!target?.m)
-    throw Error(`Entity "${target?.name}" not registred, Use @Entity or @Model.`)
-
-  const typeKeys = typeof target.m[1]
-  return {
-    table: target.m[0],
-    // @ts-ignore
-    keys: typeKeys != 'undefined' ? (typeKeys == 'string' ? { PK: target.m[1] } : { PK: target.m[1][0], SK: target.m[1][1] }) : undefined,
-    defaultSK: target?.defaultSK || undefined,
-    zip: target.m[2] || false,
-    fields: target.m[3] || [],
-  }
-}
-
-function _table(target: Function | any, opt?: ModelOpts) {
-  if (!target?.m) target.m = []
-  const table = opt ? (typeof opt == 'string' ? opt : opt?.table) : undefined
-
-  target.m[0] = table || pluralize(target.name.toLocaleUpperCase())
-}
-
-function _zip(target: Function | any) {
-  if (!target?.m) target.m = []
-  target.m[2] = true
-  target.m[3] = target?.schema || Object.keys(new target)
-}
-
-function _key(target: Function | any, pk: string, sk?: string) {
-  if (!target?.m) target.m = []
-  target.m[1] = pk && sk ? [pk, sk] : [pk]
-}
-
-export function _model(target: any, opt?: ModelOpts) {
-  _table(target, opt)
-  const notStr = typeof opt !== 'string'
-
-  if (!opt || !notStr || (opt?.zip === undefined || opt?.zip))
-    _zip(target)
-
-  const pk = opt && notStr ? opt?.partitionKey : undefined
-  const sk = opt && notStr ? opt?.sortKey : undefined
-  _key(target, pk || 'PK', sk || 'SK')
-}
-
-function _pk(target: any, prop: string) {
-  if (!target?.m) target.m = []
-  if (['string', 'undefined'].includes(typeof target.m[1])) {
-    target.m[1] = prop
-  } else {
-    target.m[1][0] = prop
-  }
-}
-
-function _sk(target: any, prop: string) {
-  if (!target?.m) target.m = []
-  if (['string', 'undefined'].includes(typeof target.m[1])) {
-    target.m[1] = []
-    target.m[1][1] = prop
-  } else {
-    target.m[1][0] = prop
-  }
-}
-
-export function Entity(target: Function): void
-export function Entity(opt?: ModelOpts): ClassDecorator
-export function Entity(...args: any[]): void | ClassDecorator {
-  if (args.length == 1 && typeof args[0] == 'function')
-    return _table(args[0])
-
-  return (target: any) => _table(target, ...args)
-}
-
-export function Model(target: Function): void
-export function Model(opt?: ModelOpts): ClassDecorator
-export function Model(...args: any[]): void | ClassDecorator {
-  if (args.length == 1 && typeof args[0] == 'function')
-    return _model(args[0])
-
-  return (target: any) => _model(target, ...args)
-}
-
-export function Zip(target: Function): void
-export function Zip(): ClassDecorator
-export function Zip(...args: any[]): void | ClassDecorator {
-  if (args.length == 1 && typeof args[0] == 'function')
-    return _zip(args[0])
-
-  return (target: any) => _zip(target)
-}
-
-export function Key(pk: string, sk?: string) {
-  return (target: any) => {
-    _key(target, pk, sk)
-  }
-}
-export const Keys = Key
-
-export function PartitionKey(attrName: string): PropertyDecorator
-export function PartitionKey(target: any, propertyKey: string): void
-export function PartitionKey(target: any, propertyKey: string | undefined, parameterIndex: number): void
-export function PartitionKey(...args: any[]): void | PropertyDecorator {
-  if (!args.length) return
-
-  if (typeof args[0] == 'function' && typeof args[1] == 'string' && args[1])
-    return _pk(args[0], args[1])
-
-  if (args.length == 1 && args[0])
-    return (target: any) => _pk(target, args[0])
-}
-
-export function SortKey(attrName: string): PropertyDecorator
-export function SortKey(target: any, propertyKey: string): void
-export function SortKey(target: any, propertyKey: string | undefined, parameterIndex: number): void
-export function SortKey(...args: any[]): void | PropertyDecorator {
-  if (!args.length) return
-
-  if (typeof args[0] == 'function' && typeof args[1] == 'string' && args[1])
-    return _sk(args[0], args[1])
-
-  if (args.length == 1 && args[0])
-    return (target: any) => _sk(target, args[0])
-}

package/src/dynamodb/index.ts

@@ -1,4 +0,0 @@
-export { Dynamodb, DocumentClient, RawClient } from './client'
-export { Model, Entity, Zip, PartitionKey, SortKey, Key, Keys } from './decorators'
-export { Schema } from './schema'
-export { Repository } from './repository'