feat: rewrite api, new type exports

Author: crashmax-dev

examples/with-fastify/src/api/users/users.controller.ts

@@ -34,7 +34,7 @@ export function userController(
     { schema: userBodySchema },
     async (request, reply) => {
       const { username, age } = request.body
-      const newUser = service.addUser(username, age)
+      const newUser = await service.addUser(username, age)
       if (!newUser) return reply.status(400).send('Username exist')
       return newUser
     }

examples/with-fastify/src/api/users/users.service.ts

@@ -1,9 +1,9 @@
 import { User, Users } from '../../dto/users.dto.js'
-import type { Steno } from '@stenodb/fastify'
+import type { AsyncProvider } from '@stenodb/fastify'
 import type { FastifyInstance } from 'fastify'
 
 export class UserService {
-  #users: Steno.NodeProvider<Users>
+  #users: AsyncProvider<Users>
 
   constructor(private readonly fastify: FastifyInstance) {
     this.#users = this.fastify.steno.get<Users>('users')!

examples/with-fastify/src/dto/users.dto.ts

@@ -1,5 +1,5 @@
 import { Exclude, Type } from 'class-transformer'
-import { IsNumber, IsString, Length } from 'class-validator'
+import { IsNumber, IsOptional, IsString, Length } from 'class-validator'
 import { Post } from './posts.dto.js'
 
 export class Users {
@@ -13,6 +13,7 @@ export class Users {
 
 export class User {
   @Exclude({ toPlainOnly: true })
+  @IsOptional()
   @IsNumber()
   userId: number
 

packages/browser/src/adapter/LocalStorage.ts

@@ -1,8 +1,8 @@
 import { BrowserStorage } from './WebStorage.js'
-import type { Steno } from '../types.js'
+import type { ClassEntity } from '@stenodb/utils'
 
 export class LocalStorage<T> extends BrowserStorage<T> {
-  constructor(name: string, entity: Steno.Entity<T>, initialData?: T) {
+  constructor(name: string, entity: ClassEntity<T>, initialData?: T) {
     super(name, localStorage, entity, initialData)
   }
 }

packages/browser/src/adapter/SessionStorage.ts

@@ -1,8 +1,8 @@
 import { BrowserStorage } from './WebStorage.js'
-import type { Steno } from '../types.js'
+import type { ClassEntity } from '@stenodb/utils'
 
 export class SessionStorage<T> extends BrowserStorage<T> {
-  constructor(name: string, entity: Steno.Entity<T>, initialData?: T) {
+  constructor(name: string, entity: ClassEntity<T>, initialData?: T) {
     super(name, sessionStorage, entity, initialData)
   }
 }

packages/browser/src/adapter/WebStorage.ts

@@ -1,6 +1,6 @@
 import { dataTransformer, entityTransformer } from '@stenodb/utils'
-import type { Steno } from '../types.js'
 import type { BaseLogger } from '@stenodb/logger'
+import type { ClassEntity } from '@stenodb/utils'
 import type { DataTransformer, EntityTransformer } from '@stenodb/utils'
 
 export class BrowserStorage<T> {
@@ -17,7 +17,7 @@ export class BrowserStorage<T> {
   constructor(
     name: string,
     storage: Storage,
-    entity: Steno.Entity<T>,
+    entity: ClassEntity<T>,
     initialData?: T
   ) {
     this.name = name

packages/browser/src/index.ts

@@ -1,4 +1,5 @@
 export * from './adapter/LocalStorage.js'
 export * from './adapter/SessionStorage.js'
 export * from './provider/BrowserProvider.js'
+export * from './provider/StorageProvider.js'
 export * from './types.js'

packages/browser/src/provider/BrowserProvider.ts

@@ -1,20 +1,20 @@
 import { StorageProvider } from './StorageProvider.js'
-import type { Steno } from '../types.js'
+import type { BrowserProviderOptions, BrowserStorageAdapter } from '../types.js'
 
 export class BrowserProvider {
-  #options: Steno.BrowserProviderOptions
+  #options: BrowserProviderOptions
 
-  constructor(options: Steno.BrowserProviderOptions = {}) {
+  constructor(options: BrowserProviderOptions = {}) {
     this.#options = options
   }
 
-  private registerAdapterModules<T>(adapter: Steno.BrowserAdapter<T>) {
+  private registerAdapterModules<T>(adapter: BrowserStorageAdapter<T>): void {
     if (!this.#options?.logger) return
     const logger = this.#options.logger(adapter.name)
     adapter.registerLogger(logger)
   }
 
-  create<T>(adapter: Steno.BrowserAdapter<T>): StorageProvider<T> {
+  create<T>(adapter: BrowserStorageAdapter<T>): StorageProvider<T> {
     this.registerAdapterModules(adapter)
     return new StorageProvider(adapter)
   }

packages/browser/src/provider/StorageProvider.ts

@@ -1,9 +1,9 @@
-import type { Steno } from '../types.js'
+import type { BrowserStorageAdapter } from '../types.js'
 
 export class StorageProvider<T> {
-  #adapter: Steno.BrowserAdapter<T>
+  #adapter: BrowserStorageAdapter<T>
 
-  constructor(adapter: Steno.BrowserAdapter<T>) {
+  constructor(adapter: BrowserStorageAdapter<T>) {
     this.#adapter = adapter
   }
 

packages/browser/src/types.ts

@@ -1,15 +1,9 @@
 import type { LocalStorage } from './adapter/LocalStorage.js'
 import type { SessionStorage } from './adapter/SessionStorage.js'
-import type { StorageProvider } from './provider/StorageProvider.js'
 import type { CreateLogger } from '@stenodb/logger'
-import type { ClassEntity } from '@stenodb/utils'
 
-export namespace Steno {
-  export type Entity<T> = ClassEntity<T>
-  export type BrowserAdapter<T> = LocalStorage<T> | SessionStorage<T>
-  export type BrowserProvider<T> = StorageProvider<T>
+export type BrowserStorageAdapter<T> = LocalStorage<T> | SessionStorage<T>
 
-  export interface BrowserProviderOptions {
-    logger?: CreateLogger
-  }
+export interface BrowserProviderOptions {
+  logger?: CreateLogger
 }

packages/fastify/package.json

@@ -22,6 +22,7 @@
   },
   "dependencies": {
     "@stenodb/node": "workspace:3.4.1",
+    "@stenodb/utils": "workspace:3.4.1",
     "class-validator-jsonschema": "5.0.0",
     "fastify-plugin": "4.5.0"
   },

packages/fastify/src/index.ts

@@ -1,13 +1,14 @@
-import { AsyncAdapter, Steno, SyncAdapter } from '@stenodb/node'
+import { AsyncAdapter, AsyncProvider } from '@stenodb/node'
 import fp from 'fastify-plugin'
 import { StenoPlugin } from './plugin.js'
 import type { StenoOptions } from './types.js'
+import type { ClassEntity } from '@stenodb/utils'
 
 const FastifySteno = fp(StenoPlugin.createInstance, {
   name: '@stenodb/fastify',
   fastify: '4.x'
 })
 
-export { FastifySteno, AsyncAdapter, SyncAdapter }
-export type { StenoOptions, Steno }
+export { FastifySteno, AsyncAdapter, AsyncProvider }
+export type { StenoOptions, ClassEntity }
 export default StenoPlugin.createInstance

packages/fastify/src/plugin.ts

@@ -1,20 +1,21 @@
-import { AsyncAdapter, NodeProvider, SyncAdapter } from '@stenodb/node'
+import { AsyncAdapter, NodeProvider } from '@stenodb/node'
 import { targetConstructorToSchema } from 'class-validator-jsonschema'
 import type { StenoOptions } from './types'
-import type { Steno } from '@stenodb/node'
+import type { AsyncProvider } from '@stenodb/node'
+import type { ClassEntity } from '@stenodb/utils'
 import type { FastifyInstance } from 'fastify'
 
 export class StenoPlugin {
   #fastify: FastifyInstance
   #options: StenoOptions
-  #provider: NodeProvider
-  #databases: Map<string, Steno.NodeProvider<any>>
+  #db: NodeProvider
+  #providers: Map<string, AsyncProvider<any>>
 
   constructor(fastify: FastifyInstance, options: StenoOptions) {
     this.#fastify = fastify
     this.#options = options
-    this.#provider = new NodeProvider(options)
-    this.#databases = new Map<string, Steno.NodeProvider<any>>()
+    this.#db = new NodeProvider(options)
+    this.#providers = new Map<string, AsyncProvider<any>>()
     this.#fastify.decorate('steno', { get: this.getDatabase.bind(this) })
   }
 
@@ -33,18 +34,17 @@ export class StenoPlugin {
     this.registerEntities()
 
     for (const adapter of this.#options.adapters) {
-      const db = await this.#provider.create(adapter)
+      let provider: AsyncProvider<any>
 
-      if (adapter instanceof SyncAdapter) {
-        db.read()
-      } else if (adapter instanceof AsyncAdapter) {
-        await db.read()
+      if (adapter instanceof AsyncAdapter) {
+        provider = await this.#db.create(adapter)
+        await provider.read()
       } else {
         throw new TypeError('Invalid adapter')
       }
 
       this.addSchema(adapter.entity)
-      this.#databases.set(adapter.fileName, db)
+      this.#providers.set(adapter.fileName, provider)
     }
   }
 
@@ -55,7 +55,7 @@ export class StenoPlugin {
     }
   }
 
-  private addSchema(entity: Steno.Entity<any>): void {
+  private addSchema(entity: ClassEntity<any>): void {
     if (this.#fastify.getSchema(entity.name)) return
     const schema = targetConstructorToSchema(
       entity,
@@ -65,9 +65,9 @@ export class StenoPlugin {
     this.#fastify.addSchema({ ...schema, $id: entity.name })
   }
 
-  private getDatabase<T extends Steno.Entity<any>>(
+  private getDatabase<T extends ClassEntity<any>>(
     name: string
-  ): Steno.NodeProvider<T> | undefined {
-    return this.#databases.get(name)
+  ): AsyncProvider<T> | undefined {
+    return this.#providers.get(name)
   }
 }

packages/fastify/src/types.ts

@@ -1,16 +1,21 @@
-import type { Steno } from '@stenodb/node'
+import type {
+  AsyncAdapter,
+  AsyncProvider,
+  NodeProviderOptions
+} from '@stenodb/node'
+import type { ClassEntity } from '@stenodb/utils'
 import type { IOptions } from 'class-validator-jsonschema/build/options'
 
-export interface StenoOptions extends Steno.NodeProviderOptions {
-  adapters: Steno.NodeAdapter<any>[]
-  entities?: Steno.Entity<any>[]
+export interface StenoOptions extends NodeProviderOptions {
+  adapters: AsyncAdapter<any>[]
+  entities?: ClassEntity<any>[]
   entityOptions?: IOptions
 }
 
 declare module 'fastify' {
   export interface FastifyInstance {
     steno: {
-      get: <T>(name: string) => Steno.NodeProvider<T> | undefined
+      get: <T>(name: string) => AsyncProvider<T> | undefined
     }
   }
 }

packages/lodash/src/browser.ts

@@ -1,11 +1,11 @@
 import lodash from 'lodash'
-import type { Steno } from '@stenodb/browser'
+import type { StorageProvider } from '@stenodb/browser'
 
 export class BrowserLodash<T> {
-  #provider: Steno.BrowserProvider<T>
+  #provider: StorageProvider<T>
   #chain: lodash.ExpChain<T>
 
-  constructor(provider: Steno.BrowserProvider<T>) {
+  constructor(provider: StorageProvider<T>) {
     this.#provider = provider
     this.#chain = lodash.chain(provider).get('data')
   }

packages/lodash/src/node.ts

@@ -1,11 +1,11 @@
 import lodash from 'lodash'
-import type { Steno } from '@stenodb/node'
+import type { AsyncProvider } from '@stenodb/node'
 
 export class NodeLodash<T> {
-  #provider: Steno.NodeProvider<T>
+  #provider: AsyncProvider<T>
   #chain: lodash.ExpChain<T>
 
-  constructor(provider: Steno.NodeProvider<T>) {
+  constructor(provider: AsyncProvider<T>) {
     this.#provider = provider
     this.#chain = lodash.chain(provider).get('data')
   }

packages/logger/test/index.test.ts

@@ -8,7 +8,7 @@ import { createRotation } from '../src/rotation.js'
 
 const logsPath = resolve('logs')
 
-test.before(async () => {
+test.beforeEach(async () => {
   if (existsSync(logsPath)) {
     await rm(logsPath, { recursive: true })
   }

packages/nest/package.json

@@ -43,7 +43,8 @@
   },
   "dependencies": {
     "@nestjs/common": "9.3.7",
-    "@stenodb/node": "workspace:3.4.1"
+    "@stenodb/node": "workspace:3.4.1",
+    "@stenodb/utils": "workspace:3.4.1"
   },
   "devDependencies": {
     "@swc/core": "1.3.35",

packages/nest/src/config.ts

@@ -1,12 +1,12 @@
 import { ConfigurableModuleBuilder } from '@nestjs/common'
-import type { Steno } from '@stenodb/node'
+import type { NodeProviderOptions } from '@stenodb/node'
 
 export const {
   ConfigurableModuleClass,
   MODULE_OPTIONS_TOKEN,
   OPTIONS_TYPE,
   ASYNC_OPTIONS_TYPE
-} = new ConfigurableModuleBuilder<Steno.NodeProviderOptions>()
+} = new ConfigurableModuleBuilder<NodeProviderOptions>()
   .setExtras({ isGlobal: false }, (definition, extras) => ({
     ...definition,
     global: extras.isGlobal

packages/nest/src/index.ts

@@ -1,3 +1,3 @@
 export * from './stenodb.module.js'
 export * from './stenodb.service.js'
-export type { Steno } from '@stenodb/node'
+export type { ClassEntity } from '@stenodb/utils'

packages/nest/src/stenodb.service.ts

@@ -1,7 +1,13 @@
 import { Inject, Injectable } from '@nestjs/common'
-import { AsyncAdapter, NodeProvider } from '@stenodb/node'
+import {
+  AsyncAdapter,
+  NodeProvider,
+  SyncAdapter,
+  SyncProvider
+} from '@stenodb/node'
 import { MODULE_OPTIONS_TOKEN, OPTIONS_TYPE } from './config.js'
-import type { Steno } from '@stenodb/node'
+import type { AsyncProvider } from '@stenodb/node'
+import type { ClassEntity } from '@stenodb/utils'
 
 @Injectable()
 export class StenoService {
@@ -13,10 +19,19 @@ export class StenoService {
 
   async create<T>(
     fileName: string,
-    entity: Steno.Entity<T>,
+    entity: ClassEntity<T>,
     initialData?: T
-  ): Promise<Steno.NodeProvider<T>> {
+  ): Promise<AsyncProvider<T>> {
     const adapter = new AsyncAdapter(fileName, entity, initialData)
     return await this.provider.create(adapter)
   }
+
+  createSync<T>(
+    fileName: string,
+    entity: ClassEntity<T>,
+    initialData?: T
+  ): SyncProvider<T> {
+    const adapter = new SyncAdapter(fileName, entity, initialData)
+    return this.provider.createSync(adapter)
+  }
 }

packages/node/src/adapter/AsyncAdapter.ts

@@ -1,9 +1,9 @@
 import { readFile } from 'node:fs/promises'
 import { BaseAdapter } from './BaseAdapter.js'
-import type { Steno } from '../types.js'
+import type { ClassEntity } from '@stenodb/utils'
 
 export class AsyncAdapter<T> extends BaseAdapter<T> {
-  constructor(fileName: string, entity: Steno.Entity<T>, initialData?: T) {
+  constructor(fileName: string, entity: ClassEntity<T>, initialData?: T) {
     super(fileName, entity, initialData)
   }