vona-cli-set-api 1.0.11 → 1.0.13

package/cli/templates/create/project/basic/boilerplate/src/suite/a-home/modules/home-user/src/.metadata/index.ts

@@ -0,0 +1,275 @@
+import type { BeanScopeUtil, TypeModuleConfig } from 'vona';
+import type { IDecoratorModelOptions } from 'vona-module-a-database';
+import type { TypeControllerOptionsActions } from 'vona-module-a-openapi';
+import type { TypeEntityOptionsFields } from 'vona-module-a-openapi';
+import type { config } from '../config/config.ts';
+
+import type { IControllerOptionsPassport } from '../controller/passport.ts';
+/** controller: end */
+/** controller: begin */
+// @ts-ignore ignore
+import type { ControllerPassport } from '../controller/passport.ts';
+
+import type { IDtoOptionsAuth } from '../dto/auth.ts';
+/** dto: end */
+/** dto: begin */
+import type { DtoAuth } from '../dto/auth.ts';
+import type { IDtoOptionsPassport } from '../dto/passport.ts';
+import type { DtoPassport } from '../dto/passport.ts';
+import type { IDtoOptionsPassportJwt } from '../dto/passportJwt.ts';
+import type { DtoPassportJwt } from '../dto/passportJwt.ts';
+import type { IEntityOptionsUser } from '../entity/user.ts';
+/** entity: end */
+/** entity: begin */
+import type { EntityUser } from '../entity/user.ts';
+
+/** model: end */
+/** model: begin */
+import type { ModelUser } from '../model/user.ts';
+/** service: end */
+/** service: begin */
+import type { ServiceAuthInnerAdapter } from '../service/authInnerAdapter.ts';
+import type { ServiceAuthTokenAdapter } from '../service/authTokenAdapter.ts';
+import type { ServicePassportAdapter } from '../service/passportAdapter.ts';
+import type { ServiceRedisToken } from '../service/redisToken.ts';
+import type { ServiceUserInnerAdapter } from '../service/userInnerAdapter.ts';
+/** config: end */
+/** scope: begin */
+import { BeanScopeBase } from 'vona';
+/** service: end */
+/** service: begin */
+
+import { Scope } from 'vona-module-a-bean';
+import 'vona';
+import 'vona';
+import 'vona';
+import 'vona';
+import 'vona';
+import 'vona';
+
+import 'vona';
+/** model: end */
+/** meta: begin */
+export * from '../bean/meta.version.ts';
+declare module 'vona-module-a-database' {
+
+  export interface IEntityRecord {
+    'home-user:user': IEntityOptionsUser;
+  }
+
+}
+declare module 'vona-module-home-user' {
+
+}
+export interface IModuleEntity {
+  user: EntityUser;
+}
+/** entity: end */
+/** entity: begin */
+declare module 'vona-module-home-user' {
+
+  export interface EntityUser {
+    $column: <K extends keyof Omit<EntityUser, '$column' | '$columns' | '$table'>>(column: K) => K;
+    $columns: <K extends keyof Omit<EntityUser, '$column' | '$columns' | '$table'>>(...columns: K[]) => K[];
+  }
+
+  export interface IEntityOptionsUser {
+    fields?: TypeEntityOptionsFields<EntityUser, IEntityOptionsUser['fieldsMore']>;
+  }
+}
+/** controller: end */
+/** config: begin */
+export * from '../config/config.ts';
+declare module 'vona-module-a-database' {
+
+  export interface IModelRecord {
+    'home-user:user': IDecoratorModelOptions;
+  }
+
+}
+declare module 'vona-module-home-user' {
+
+  export interface ModelUser {
+    /** @internal */
+    get scope(): ScopeModuleHomeUser;
+  }
+}
+export interface IModuleModel {
+  user: ModelUser;
+}
+/** service: end */
+/** controller: begin */
+export * from '../controller/passport.ts';
+declare module 'vona' {
+
+  export interface IMetaRecord {
+    'home-user:version': never;
+  }
+
+}
+declare module 'vona-module-home-user' {
+
+  export interface MetaVersion {
+    /** @internal */
+    get scope(): ScopeModuleHomeUser;
+  }
+}
+/** meta: end */
+/** dto: begin */
+export * from '../dto/auth.ts';
+export * from '../dto/passport.ts';
+export * from '../dto/passportJwt.ts';
+declare module 'vona-module-a-web' {
+
+  export interface IDtoRecord {
+    'home-user:auth': IDtoOptionsAuth;
+    'home-user:passport': IDtoOptionsPassport;
+    'home-user:passportJwt': IDtoOptionsPassportJwt;
+  }
+
+}
+declare module 'vona-module-home-user' {
+
+}
+declare module 'vona-module-home-user' {
+
+  export interface IDtoOptionsAuth {
+    fields?: TypeEntityOptionsFields<DtoAuth, IDtoOptionsAuth['fieldsMore']>;
+  }
+
+  export interface IDtoOptionsPassport {
+    fields?: TypeEntityOptionsFields<DtoPassport, IDtoOptionsPassport['fieldsMore']>;
+  }
+
+  export interface IDtoOptionsPassportJwt {
+    fields?: TypeEntityOptionsFields<DtoPassportJwt, IDtoOptionsPassportJwt['fieldsMore']>;
+  }
+}
+/** entity: begin */
+export * from '../entity/user.ts';
+/** entity: end */
+/** model: begin */
+export * from '../model/user.ts';
+/** dto: end */
+/** service: begin */
+export * from '../service/authInnerAdapter.ts';
+export * from '../service/authTokenAdapter.ts';
+export * from '../service/passportAdapter.ts';
+declare module 'vona-module-a-web' {
+
+  export interface IServiceRecord {
+    'home-user:authInnerAdapter': never;
+    'home-user:authTokenAdapter': never;
+    'home-user:passportAdapter': never;
+    'home-user:redisToken': never;
+    'home-user:userInnerAdapter': never;
+  }
+
+}
+declare module 'vona-module-home-user' {
+
+  export interface ServiceAuthInnerAdapter {
+    /** @internal */
+    get scope(): ScopeModuleHomeUser;
+  }
+
+  export interface ServiceAuthTokenAdapter {
+    /** @internal */
+    get scope(): ScopeModuleHomeUser;
+  }
+
+  export interface ServicePassportAdapter {
+    /** @internal */
+    get scope(): ScopeModuleHomeUser;
+  }
+
+  export interface ServiceRedisToken {
+    /** @internal */
+    get scope(): ScopeModuleHomeUser;
+  }
+
+  export interface ServiceUserInnerAdapter {
+    /** @internal */
+    get scope(): ScopeModuleHomeUser;
+  }
+}
+export interface IModuleService {
+  authInnerAdapter: ServiceAuthInnerAdapter;
+  authTokenAdapter: ServiceAuthTokenAdapter;
+  passportAdapter: ServicePassportAdapter;
+  redisToken: ServiceRedisToken;
+  userInnerAdapter: ServiceUserInnerAdapter;
+}
+declare module 'vona' {
+  export interface IBeanRecordGeneral {
+    'home-user.service.authInnerAdapter': ServiceAuthInnerAdapter;
+    'home-user.service.authTokenAdapter': ServiceAuthTokenAdapter;
+    'home-user.service.passportAdapter': ServicePassportAdapter;
+    'home-user.service.redisToken': ServiceRedisToken;
+    'home-user.service.userInnerAdapter': ServiceUserInnerAdapter;
+  }
+}
+export * from '../service/redisToken.ts';
+declare module 'vona-module-a-web' {
+
+  export interface IControllerRecord {
+    'home-user:passport': IControllerOptionsPassport;
+  }
+
+}
+declare module 'vona-module-home-user' {
+
+  export interface ControllerPassport {
+    /** @internal */
+    get scope(): ScopeModuleHomeUser;
+  }
+}
+declare module 'vona-module-home-user' {
+
+  export interface IControllerOptionsPassport {
+    actions?: TypeControllerOptionsActions<ControllerPassport>;
+  }
+}
+declare module 'vona-module-a-web' {
+  export interface IApiPathGetRecord {
+    '/home/user/passport/current': undefined;
+    '/home/user/passport/login/:module/:providerName/:clientName?': undefined;
+    '/home/user/passport/associate/:module/:providerName/:clientName?': undefined;
+    '/home/user/passport/migrate/:module/:providerName/:clientName?': undefined;
+  }
+  export interface IApiPathPostRecord {
+    '/home/user/passport/logout': undefined;
+    '/home/user/passport/login': undefined;
+    '/home/user/passport/refreshAuthToken': undefined;
+    '/home/user/passport/createPassportJwtFromOauthCode': undefined;
+  }
+
+}
+export * from '../service/userInnerAdapter.ts';
+
+@Scope()
+export class ScopeModuleHomeUser extends BeanScopeBase {}
+
+export interface ScopeModuleHomeUser {
+  util: BeanScopeUtil;
+  config: TypeModuleConfig<typeof config>;
+  entity: IModuleEntity;
+  model: IModuleModel;
+  service: IModuleService;
+}
+declare module 'vona' {
+  export interface IBeanScopeRecord {
+    'home-user': ScopeModuleHomeUser;
+  }
+
+  export interface IBeanScopeContainer {
+    homeUser: ScopeModuleHomeUser;
+  }
+
+  export interface IBeanScopeConfig {
+    'home-user': ReturnType<typeof config>;
+  }
+
+}
+
+/** scope: end */

package/cli/templates/create/project/basic/boilerplate/src/suite/a-home/modules/home-user/src/.metadata/this.ts

@@ -0,0 +1,2 @@
+export const __ThisModule__ = 'home-user';
+export { ScopeModuleHomeUser as ScopeModule } from './index.ts';

package/cli/templates/create/project/basic/boilerplate/src/suite/a-home/modules/home-user/src/bean/meta.version.ts

@@ -0,0 +1,30 @@
+import type { IMetaVersionInit, IMetaVersionInitOptions, IMetaVersionUpdate, IMetaVersionUpdateOptions } from 'vona-module-a-version';
+import { BeanBase } from 'vona';
+import { Meta } from 'vona-module-a-meta';
+
+@Meta()
+export class MetaVersion extends BeanBase implements IMetaVersionUpdate, IMetaVersionInit {
+  async update(options: IMetaVersionUpdateOptions) {
+    if (options.version === 1) {
+      // homeUser
+      const entityUser = this.scope.entity.user;
+      await this.bean.model.createTable(entityUser.$table, table => {
+        table.basicFields();
+        table.string(entityUser.$column('name'), 255);
+        table.string(entityUser.$column('avatar'), 255);
+        table.string(entityUser.$column('locale'), 255);
+      });
+    }
+  }
+
+  async init(options: IMetaVersionInitOptions) {
+    if (options.version === 1) {
+      // admin
+      await this.scope.model.user.insert({
+        name: 'admin',
+        avatar: ':emoji:flower',
+        locale: undefined,
+      });
+    }
+  }
+}

package/cli/templates/create/project/basic/boilerplate/src/suite/a-home/modules/home-user/src/config/config.ts

@@ -0,0 +1,13 @@
+import type { VonaApplication } from 'vona';
+import type { IServiceRecord } from 'vona-module-a-web';
+
+export function config(_app: VonaApplication) {
+  return {
+    adapter: {
+      authInner: 'a-auth:authInnerAdapter' as keyof IServiceRecord,
+    },
+    redisToken: {
+      maxAge: 30 * 24 * 60 * 60,
+    },
+  };
+}

package/cli/templates/create/project/basic/boilerplate/src/suite/a-home/modules/home-user/src/controller/passport.ts

@@ -0,0 +1,115 @@
+import type { IAuthenticateOptions, IAuthProviderRecord } from 'vona-module-a-auth';
+import type { IJwtToken } from 'vona-module-a-jwt';
+import type { IDecoratorControllerOptions } from 'vona-module-a-web';
+import type { EntityUser } from '../entity/user.ts';
+import { BeanBase } from 'vona';
+import { DtoAuthSimple } from 'vona-module-a-authsimple';
+import { DtoJwtToken } from 'vona-module-a-jwt';
+import { Api, Arg, v } from 'vona-module-a-openapi';
+import { Passport } from 'vona-module-a-user';
+import { Controller, Web } from 'vona-module-a-web';
+import { z } from 'zod';
+import { DtoPassport } from '../dto/passport.ts';
+import { DtoPassportJwt } from '../dto/passportJwt.ts';
+
+export interface IControllerOptionsPassport extends IDecoratorControllerOptions {}
+
+@Controller<IControllerOptionsPassport>('passport')
+export class ControllerPassport extends BeanBase {
+  @Web.get('current')
+  @Api.body(v.optional(), v.object(DtoPassport))
+  current(): DtoPassport | undefined {
+    return this._combineDtoPassport();
+  }
+
+  @Web.post('logout')
+  async logout() {
+    return await this.bean.passport.signout();
+  }
+
+  @Web.post('login')
+  @Passport.public()
+  @Api.body(v.object(DtoPassportJwt))
+  async loginSimple(@Arg.body() clientOptions: DtoAuthSimple): Promise<DtoPassportJwt> {
+    const jwt = await this.bean.authSimple.authenticate(clientOptions, 'default');
+    return this._combineDtoPassportJwt(jwt);
+  }
+
+  @Web.get('login/:module/:providerName/:clientName?')
+  @Passport.public()
+  @Api.body(v.object(DtoPassportJwt))
+  async login<T extends keyof IAuthProviderRecord>(
+    @Arg.param('module') module: string,
+    @Arg.param('providerName') providerName: string,
+    @Arg.param('clientName', z.string().optional()) clientName?: IAuthenticateOptions<IAuthProviderRecord[T]>['clientName'],
+    @Arg.query('redirect', v.optional()) redirect?: string,
+  ): Promise<DtoPassportJwt> {
+    const jwt = await this.bean.auth.authenticate(`${module}:${providerName}` as T, {
+      state: { intention: 'login', redirect },
+      clientName,
+    });
+    return this._combineDtoPassportJwt(jwt);
+  }
+
+  @Web.get('associate/:module/:providerName/:clientName?')
+  @Api.body(v.object(DtoPassportJwt))
+  async associate<T extends keyof IAuthProviderRecord>(
+    @Arg.param('module') module: string,
+    @Arg.param('providerName') providerName: string,
+    @Arg.param('clientName', z.string().optional()) clientName?: IAuthenticateOptions<IAuthProviderRecord[T]>['clientName'],
+    @Arg.query('redirect', v.optional()) redirect?: string,
+  ): Promise<DtoPassportJwt> {
+    const jwt = await this.bean.auth.authenticate(`${module}:${providerName}` as T, {
+      state: { intention: 'associate', redirect },
+      clientName,
+    });
+    return this._combineDtoPassportJwt(jwt);
+  }
+
+  @Web.get('migrate/:module/:providerName/:clientName?')
+  @Api.body(v.object(DtoPassportJwt))
+  async migrate<T extends keyof IAuthProviderRecord>(
+    @Arg.param('module') module: string,
+    @Arg.param('providerName') providerName: string,
+    @Arg.param('clientName', z.string().optional()) clientName?: IAuthenticateOptions<IAuthProviderRecord[T]>['clientName'],
+    @Arg.query('redirect', v.optional()) redirect?: string,
+  ): Promise<DtoPassportJwt> {
+    const jwt = await this.bean.auth.authenticate(`${module}:${providerName}` as T, {
+      state: { intention: 'migrate', redirect },
+      clientName,
+    });
+    return this._combineDtoPassportJwt(jwt);
+  }
+
+  @Web.post('refreshAuthToken')
+  @Passport.public()
+  @Api.body(v.object(DtoJwtToken))
+  async refreshAuthToken(@Arg.body('refreshToken') refreshToken: string): Promise<DtoJwtToken> {
+    return await this.bean.passport.refreshAuthToken(refreshToken);
+  }
+
+  @Web.post('createPassportJwtFromOauthCode')
+  @Passport.public()
+  @Api.body(v.object(DtoPassportJwt))
+  async createPassportJwtFromOauthCode(@Arg.body('code') code: string): Promise<DtoPassportJwt> {
+    const jwt = await this.bean.passport.createAuthTokenFromOauthCode(code);
+    return this._combineDtoPassportJwt(jwt);
+  }
+
+  private _combineDtoPassportJwt(jwt?: IJwtToken): DtoPassportJwt {
+    if (!jwt) this.app.throw(403);
+    return {
+      passport: this._combineDtoPassport()!,
+      jwt: jwt as DtoJwtToken,
+    };
+  }
+
+  private _combineDtoPassport(): DtoPassport | undefined {
+    const passport = this.bean.passport.getCurrent();
+    if (!passport) return;
+    return {
+      user: passport.user as EntityUser,
+      auth: { id: passport.auth!.id },
+    };
+  }
+}

package/cli/templates/create/project/basic/boilerplate/src/suite/a-home/modules/home-user/src/dto/auth.ts

@@ -0,0 +1,13 @@
+import type { TableIdentity } from 'vona-module-a-database';
+import type { IAuthBase } from 'vona-module-a-user';
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+import { Api, v } from 'vona-module-a-openapi';
+import { Dto } from 'vona-module-a-web';
+
+export interface IDtoOptionsAuth extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsAuth>()
+export class DtoAuth implements IAuthBase {
+  @Api.field(v.tableIdentity())
+  id: TableIdentity;
+}

package/cli/templates/create/project/basic/boilerplate/src/suite/a-home/modules/home-user/src/dto/passport.ts

@@ -0,0 +1,16 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+import { Api } from 'vona-module-a-openapi';
+import { Dto } from 'vona-module-a-web';
+import { EntityUser } from '../entity/user.ts';
+import { DtoAuth } from './auth.ts';
+
+export interface IDtoOptionsPassport extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsPassport>()
+export class DtoPassport {
+  @Api.field()
+  user: EntityUser;
+
+  @Api.field()
+  auth: DtoAuth;
+}

package/cli/templates/create/project/basic/boilerplate/src/suite/a-home/modules/home-user/src/dto/passportJwt.ts

@@ -0,0 +1,16 @@
+import type { IDecoratorDtoOptions } from 'vona-module-a-web';
+import { DtoJwtToken } from 'vona-module-a-jwt';
+import { Api } from 'vona-module-a-openapi';
+import { Dto } from 'vona-module-a-web';
+import { DtoPassport } from './passport.ts';
+
+export interface IDtoOptionsPassportJwt extends IDecoratorDtoOptions {}
+
+@Dto<IDtoOptionsPassportJwt>()
+export class DtoPassportJwt {
+  @Api.field()
+  passport: DtoPassport;
+
+  @Api.field()
+  jwt: DtoJwtToken;
+}

package/cli/templates/create/project/basic/boilerplate/src/suite/a-home/modules/home-user/src/entity/user.ts

@@ -0,0 +1,19 @@
+import type { ILocaleInfos } from 'vona';
+import type { IDecoratorEntityOptions } from 'vona-module-a-database';
+import { Entity, EntityBase } from 'vona-module-a-database';
+import { Api, v } from 'vona-module-a-openapi';
+import { z } from 'zod';
+
+export interface IEntityOptionsUser extends IDecoratorEntityOptions {}
+
+@Entity<IEntityOptionsUser>('homeUser')
+export class EntityUser extends EntityBase {
+  @Api.field()
+  name: string;
+
+  @Api.field(v.optional())
+  avatar?: string;
+
+  @Api.field(z.string().optional())
+  locale?: keyof ILocaleInfos | undefined;
+}

package/cli/templates/create/project/basic/boilerplate/src/suite/a-home/modules/home-user/src/index.ts

@@ -0,0 +1,3 @@
+export * from './.metadata/index.ts';
+export * from './lib/index.ts';
+export * from './types/index.ts';

package/cli/templates/create/project/basic/boilerplate/src/suite/a-home/modules/home-user/src/lib/authAdapter.ts

@@ -0,0 +1,11 @@
+import type { TableIdentity } from 'vona-module-a-database';
+import type { IAuthBase } from 'vona-module-a-user';
+import type { IAuth } from '../types/auth.ts';
+import { cast } from 'vona';
+import { setAuthAdapter } from 'vona-module-a-user';
+
+setAuthAdapter({ getAuthId });
+
+function getAuthId(auth: IAuthBase): TableIdentity {
+  return cast<IAuth>(auth).id;
+}

package/cli/templates/create/project/basic/boilerplate/src/suite/a-home/modules/home-user/src/lib/index.ts

@@ -0,0 +1,2 @@
+export * from './authAdapter.ts';
+export * from './userAdapter.ts';

package/cli/templates/create/project/basic/boilerplate/src/suite/a-home/modules/home-user/src/lib/userAdapter.ts

@@ -0,0 +1,28 @@
+import type { ILocaleInfos } from 'vona';
+import type { TableIdentity } from 'vona-module-a-database';
+import type { IUserBase } from 'vona-module-a-user';
+import type { IUser } from '../types/user.ts';
+import { cast } from 'vona';
+import { setUserAdapter } from 'vona-module-a-user';
+
+setUserAdapter({ getUserId, getUserName, getUserAvatar, getUserLocale, getUserAnonymous });
+
+function getUserId(user: IUserBase): TableIdentity {
+  return cast<IUser>(user).id;
+}
+
+function getUserName(user: IUserBase): string {
+  return cast<IUser>(user).name;
+}
+
+function getUserAvatar(user: IUserBase): string | undefined {
+  return cast<IUser>(user).avatar;
+}
+
+function getUserLocale(user: IUserBase): keyof ILocaleInfos | undefined {
+  return cast<IUser>(user).locale;
+}
+
+function getUserAnonymous(user: IUserBase): boolean {
+  return cast<IUser>(user).id === -1;
+}

package/cli/templates/create/project/basic/boilerplate/src/suite/a-home/modules/home-user/src/model/user.ts

@@ -0,0 +1,5 @@
+import { BeanModelBase, Model } from 'vona-module-a-database';
+import { EntityUser } from '../entity/user.ts';
+
+@Model({ entity: EntityUser })
+export class ModelUser extends BeanModelBase<EntityUser> {}

package/cli/templates/create/project/basic/boilerplate/src/suite/a-home/modules/home-user/src/service/authInnerAdapter.ts

@@ -0,0 +1,14 @@
+import type { IAuthBase, IAuthInnerAdapter } from 'vona-module-a-user';
+import type { IAuth } from '../types/auth.ts';
+import { BeanBase, beanFullNameFromOnionName } from 'vona';
+import { Service } from 'vona-module-a-web';
+
+@Service()
+export class ServiceAuthInnerAdapter extends BeanBase implements IAuthInnerAdapter {
+  async get(auth: Partial<IAuth>): Promise<IAuthBase | undefined> {
+    const beanFullName = beanFullNameFromOnionName(this.scope.config.adapter.authInner, 'service');
+    const beanAuth = this.bean._getBean<IAuthInnerAdapter>(beanFullName as never);
+    if (beanAuth) return await beanAuth.get(auth);
+    return auth as unknown as IAuthBase | undefined;
+  }
+}

package/cli/templates/create/project/basic/boilerplate/src/suite/a-home/modules/home-user/src/service/authTokenAdapter.ts

@@ -0,0 +1,34 @@
+import type { IAuthTokenAdapter, IUserBase } from 'vona-module-a-user';
+import type { IPayloadData } from '../types/passport.ts';
+import { BeanBase, createHash, uuidv4 } from 'vona';
+import { Service } from 'vona-module-a-web';
+
+@Service()
+export class ServiceAuthTokenAdapter extends BeanBase implements IAuthTokenAdapter {
+  async create(payloadData: IPayloadData): Promise<IPayloadData> {
+    const token = (payloadData.authId.toString() === '-1') ? createHash(payloadData.authId.toString()) : uuidv4();
+    const payloadDataNew = Object.assign({}, payloadData, { token });
+    await this.scope.service.redisToken.create(payloadDataNew);
+    return payloadDataNew;
+  }
+
+  async retrieve(payloadData: IPayloadData): Promise<IPayloadData | undefined> {
+    return await this.scope.service.redisToken.retrieve(payloadData);
+  }
+
+  async verify(payloadData: IPayloadData): Promise<boolean> {
+    return await this.scope.service.redisToken.verify(payloadData);
+  }
+
+  async refresh(payloadData: IPayloadData): Promise<void> {
+    await this.scope.service.redisToken.refresh(payloadData);
+  }
+
+  async remove(payloadData: IPayloadData): Promise<void> {
+    await this.scope.service.redisToken.remove(payloadData);
+  }
+
+  async removeAll(user: IUserBase): Promise<void> {
+    await this.scope.service.redisToken.removeAll(user);
+  }
+}

package/cli/templates/create/project/basic/boilerplate/src/suite/a-home/modules/home-user/src/service/passportAdapter.ts

@@ -0,0 +1,30 @@
+import type { IPassportAdapter, IPassportBase } from 'vona-module-a-user';
+import type { IPassport, IPayloadData } from '../types/passport.ts';
+import type { IUser } from '../types/user.ts';
+import { BeanBase } from 'vona';
+import { Service } from 'vona-module-a-web';
+
+@Service()
+export class ServicePassportAdapter extends BeanBase implements IPassportAdapter {
+  async isAdmin(user: IUser): Promise<boolean> {
+    return user.name === 'admin';
+  }
+
+  async setCurrent(passport: IPassport | undefined): Promise<IPassport | undefined> {
+    return passport;
+  }
+
+  async serialize(passport: IPassportBase): Promise<IPayloadData> {
+    const userId = passport.user!.id;
+    const authId = passport.auth!.id;
+    return { userId, authId };
+  }
+
+  async deserialize(payloadData: IPayloadData): Promise<IPassportBase | undefined> {
+    const user = await this.bean.userInner.get({ id: payloadData.userId });
+    if (!user) return;
+    const auth = await this.bean.authInner.get({ id: payloadData.authId });
+    if (!auth) return;
+    return { user, auth };
+  }
+}