push.rocks/smartuniverse
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fix(core): update

Browse Source
This commit is contained in:
Philipp Kunz 2020-09-24 18:17:52 +00:00
parent 5d8c2064e0
commit 820ce76fe3
19 changed files with 140 additions and 104 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
.gitignore vendored
View File

@ -15,8 +15,6 @@ node_modules/
# builds
dist/
dist_web/
dist_serve/
dist_ts_web/
dist_*/
# custom

31
.gitlab-ci.yml
View File

@ -19,22 +19,35 @@ mirror:
stage: security
script:
- npmci git mirror
only:
- tags
tags:
- lossless
- docker
- notpriv
snyk:
auditProductionDependencies:
image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
stage: security
script:
- npmci npm prepare
- npmci command npm install -g snyk
- npmci command npm install --ignore-scripts
- npmci command snyk test
- npmci command npm install --production --ignore-scripts
- npmci command npm config set registry https://registry.npmjs.org
- npmci command npm audit --audit-level=high --only=prod --production
tags:
- lossless
- docker
- notpriv
auditDevDependencies:
image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
stage: security
script:
- npmci npm prepare
- npmci command npm install --ignore-scripts
- npmci command npm config set registry https://registry.npmjs.org
- npmci command npm audit --audit-level=high --only=dev
tags:
- docker
allow_failure: true
# ====================
# test stage
@ -49,9 +62,7 @@ testStable:
- npmci npm test
coverage: /\d+.?\d+?\%\s*coverage/
tags:
- lossless
- docker
- priv
testBuild:
stage: test
@ -62,9 +73,7 @@ testBuild:
- npmci command npm run build
coverage: /\d+.?\d+?\%\s*coverage/
tags:
- lossless
- docker
- notpriv
release:
stage: release
@ -84,6 +93,8 @@ release:
codequality:
stage: metadata
allow_failure: true
only:
- tags
script:
- npmci command npm install -g tslint typescript
- npmci npm prepare

26
.vscode/settings.json vendored Normal file
View File

@ -0,0 +1,26 @@
{
"json.schemas": [
{
"fileMatch": ["/npmextra.json"],
"schema": {
"type": "object",
"properties": {
"npmci": {
"type": "object",
"description": "settings for npmci"
},
"gitzone": {
"type": "object",
"description": "settings for gitzone",
"properties": {
"projectType": {
"type": "string",
"enum": ["website", "element", "service", "npm", "wcc"]
}
}
}
}
}
}
]
}

1
npmextra.json
View File

@ -1,5 +1,6 @@
{
"gitzone": {
"projectType": "npm",
"module": {
"githost": "gitlab.com",
"gitscope": "pushrocks",

12
package.json
View File

@ -3,8 +3,8 @@
"version": "1.0.99",
"private": false,
"description": "messaging service for your micro services",
"main": "dist/index.js",
"typings": "dist/index.d.ts",
"main": "dist_ts/index.js",
"typings": "dist_ts/index.d.ts",
"author": "Lossless GmbH",
"license": "MIT",
"scripts": {
@ -43,11 +43,15 @@
"ts/**/*",
"ts_web/**/*",
"dist/**/*",
"dist_web/**/*",
"dist_*/**/*",
"dist_ts/**/*",
"dist_ts_web/**/*",
"assets/**/*",
"cli.js",
"npmextra.json",
"readme.md"
],
"browserslist": [
"last 1 chrome versions"
]
}
}

23
readme.md
View File

@ -8,13 +8,20 @@ messaging service for micro services
* [docs (typedoc)](https://pushrocks.gitlab.io/smartuniverse/)
## Status for master
[![build status](https://gitlab.com/pushrocks/smartuniverse/badges/master/build.svg)](https://gitlab.com/pushrocks/smartuniverse/commits/master)
[![coverage report](https://gitlab.com/pushrocks/smartuniverse/badges/master/coverage.svg)](https://gitlab.com/pushrocks/smartuniverse/commits/master)
[![npm downloads per month](https://img.shields.io/npm/dm/@pushrocks/smartuniverse.svg)](https://www.npmjs.com/package/@pushrocks/smartuniverse)
[![Known Vulnerabilities](https://snyk.io/test/npm/@pushrocks/smartuniverse/badge.svg)](https://snyk.io/test/npm/@pushrocks/smartuniverse)
[![TypeScript](https://img.shields.io/badge/TypeScript->=%203.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
[![node](https://img.shields.io/badge/node->=%2010.x.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
[![JavaScript Style Guide](https://img.shields.io/badge/code%20style-prettier-ff69b4.svg)](https://prettier.io/)
Status Category | Status Badge
-- | --
GitLab Pipelines | [![pipeline status](https://gitlab.com/pushrocks/smartuniverse/badges/master/pipeline.svg)](https://lossless.cloud)
GitLab Pipline Test Coverage | [![coverage report](https://gitlab.com/pushrocks/smartuniverse/badges/master/coverage.svg)](https://lossless.cloud)
npm | [![npm downloads per month](https://badgen.net/npm/dy/@pushrocks/smartuniverse)](https://lossless.cloud)
Snyk | [![Known Vulnerabilities](https://badgen.net/snyk/pushrocks/smartuniverse)](https://lossless.cloud)
TypeScript Support | [![TypeScript](https://badgen.net/badge/TypeScript/>=%203.x/blue?icon=typescript)](https://lossless.cloud)
node Support | [![node](https://img.shields.io/badge/node->=%2010.x.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
Code Style | [![Code Style](https://badgen.net/badge/style/prettier/purple)](https://lossless.cloud)
PackagePhobia (total standalone install weight) | [![PackagePhobia](https://badgen.net/packagephobia/install/@pushrocks/smartuniverse)](https://lossless.cloud)
PackagePhobia (package size on registry) | [![PackagePhobia](https://badgen.net/packagephobia/publish/@pushrocks/smartuniverse)](https://lossless.cloud)
BundlePhobia (total size when bundled) | [![BundlePhobia](https://badgen.net/bundlephobia/minzip/@pushrocks/smartuniverse)](https://lossless.cloud)
Platform support | [![Supports Windows 10](https://badgen.net/badge/supports%20Windows%2010/yes/green?icon=windows)](https://lossless.cloud) [![Supports Mac OS X](https://badgen.net/badge/supports%20Mac%20OS%20X/yes/green?icon=apple)](https://lossless.cloud)
## Usage
@ -33,7 +40,7 @@ Think Kafka, but without Kafka.
import * as smartuniverse from '@pushrocks/smartuniverse';
const myUniverse = new smartuniverse.Universe({
messageExpiryInMilliseconds: 60000 // the standard time in milliseconds until a message expires
messageExpiryInMilliseconds: 60000, // the standard time in milliseconds until a message expires
});
// create as many channels as you like

32
test/test.ts
View File

@ -10,17 +10,17 @@ let testClientUniverse2: smartuniverse.ClientUniverse;
let testClientChannel: smartuniverse.ClientUniverseChannel;
const testServerData = {
serverAddress: 'http://localhost:8765'
serverAddress: 'http://localhost:8765',
};
const testChannelData = {
channelName: 'awesomeTestChannel',
channelPass: 'awesomeChannelPass'
channelPass: 'awesomeChannelPass',
};
tap.test('first test', async () => {
testUniverse = new smartuniverse.Universe({
messageExpiryInMilliseconds: 1000
messageExpiryInMilliseconds: 1000,
});
});
@ -32,7 +32,7 @@ tap.test('add a message to the SmartUniverse', async () => {
tap.test('create smartuniverse client', async () => {
testClientUniverse = new smartuniverse.ClientUniverse({
serverAddress: testServerData.serverAddress,
autoReconnect: true
autoReconnect: true,
});
expect(testClientUniverse).to.be.instanceof(smartuniverse.ClientUniverse);
});
@ -56,7 +56,7 @@ tap.test('should get a observable correctly', async () => {
tap.test('should send a message correctly', async () => {
await testClientUniverse.getChannel(testChannelData.channelName).sendMessage({
messageText: 'hello'
messageText: 'hello',
});
});
@ -67,25 +67,25 @@ tap.test('universe should contain the sent message', async () => {
tap.test('a second client should be able to subscibe', async () => {
testClientUniverse2 = new smartuniverse.ClientUniverse({
serverAddress: testServerData.serverAddress,
autoReconnect: true
autoReconnect: true,
});
testClientUniverse2.addChannel(testChannelData.channelName, testChannelData.channelPass);
await testClientUniverse2.start();
});
tap.test('should receive a message correctly', async tools => {
tap.test('should receive a message correctly', async (tools) => {
const done = tools.defer();
const testChannel = testClientUniverse.getChannel(testChannelData.channelName);
const testChannel2 = testClientUniverse2.getChannel(testChannelData.channelName);
const subscription = testChannel2.subscribe(messageArg => {
const subscription = testChannel2.subscribe((messageArg) => {
if (messageArg.messageText === 'hellothere') {
console.log('Yay##########');
done.resolve();
}
});
await testChannel.sendMessage({
messageText: 'hellothere'
messageText: 'hellothere',
});
await done.promise;
});
@ -103,33 +103,33 @@ interface IDemoReqRes {
tap.test('ReactionRequest and ReactionResponse should work', async () => {
const reactionResponse = new smartuniverse.ReactionResponse<IDemoReqRes>({
channels: [testUniverse.getChannel(testChannelData.channelName)],
funcDef: async reqData => {
funcDef: async (reqData) => {
console.log(reqData);
return {
hereso: 'Hello there'
hereso: 'Hello there',
};
},
method: 'demo'
method: 'demo',
});
const reactionRequest = new smartuniverse.ReactionRequest<IDemoReqRes>({
method: 'demo'
method: 'demo',
});
const reactionResult = await reactionRequest.fire(
[testClientUniverse2.getChannel(testChannelData.channelName)],
{
wowso: 'wowza'
wowso: 'wowza',
}
);
const result = await reactionResult.getFirstResult();
console.log(result);
});
tap.test('should disconnect the client correctly', async tools => {
tap.test('should disconnect the client correctly', async (tools) => {
await testClientUniverse.stop();
await testClientUniverse2.stop();
});
tap.test('should end the server correctly', async tools => {
tap.test('should end the server correctly', async (tools) => {
await testUniverse.stopServer();
});

9
ts/smartuniverse.classes.broadcastevent.ts
View File

@ -7,14 +7,9 @@ import * as plugins from './smartuniverse.plugins';
export class BroadcastEvent<T extends plugins.typedrequestInterfaces.ITypedEvent<any>> {
public eventSubject = new plugins.smartrx.rxjs.Subject<T['payload']>();
constructor() {
};
public fire(eventPayloadArg: T['payload']) {
};
constructor() {}
public fire(eventPayloadArg: T['payload']) {}
public subscribe(funcArg: (nextArg: T['payload']) => void): plugins.smartrx.rxjs.Subscription {
return this.eventSubject.subscribe(funcArg);

22
ts/smartuniverse.classes.clientuniverse.ts
View File

@ -57,7 +57,7 @@ export class ClientUniverse {
* @param passphraseArg
*/
public getChannel(channelName: string): ClientUniverseChannel {
const clientUniverseChannel = this.clientUniverseCache.channelMap.find(channel => {
const clientUniverseChannel = this.clientUniverseCache.channelMap.find((channel) => {
return channel.name === channelName;
});
return clientUniverseChannel;
@ -69,7 +69,7 @@ export class ClientUniverse {
*/
public removeChannel(channelNameArg, notifyServer = true) {
const clientUniverseChannel = this.clientUniverseCache.channelMap.findOneAndRemove(
channelItemArg => {
(channelItemArg) => {
return channelItemArg.name === channelNameArg;
}
);
@ -99,11 +99,11 @@ export class ClientUniverse {
password: 'UniverseClient',
port: parseInt(parsedURL.port, 10),
role: 'UniverseClient',
url: parsedURL.protocol + '//' + parsedURL.hostname
url: parsedURL.protocol + '//' + parsedURL.hostname,
};
this.smartsocketClient = new SmartsocketClient(socketConfig);
this.smartsocketClient.eventSubject.subscribe(async eventArg => {
this.smartsocketClient.eventSubject.subscribe(async (eventArg) => {
switch (eventArg) {
case 'disconnected':
this.disconnect('upstreamEvent');
@ -119,14 +119,14 @@ export class ClientUniverse {
funcName: 'unsubscribe',
allowedRoles: [],
funcDef: async (dataArg: interfaces.IServerUnsubscribeActionPayload) => {
const channel = this.clientUniverseCache.channelMap.find(channelArg => {
const channel = this.clientUniverseCache.channelMap.find((channelArg) => {
return channelArg.name === dataArg.name;
});
if (channel) {
channel.unsubscribe();
}
return {};
}
},
});
/**
@ -137,7 +137,7 @@ export class ClientUniverse {
>({
funcName: 'processMessage',
allowedRoles: [],
funcDef: async messageDescriptorArg => {
funcDef: async (messageDescriptorArg) => {
logger.log('info', 'Got message from server');
const clientUniverseMessage = ClientUniverseMessage.createMessageFromMessageDescriptor(
messageDescriptorArg
@ -149,14 +149,14 @@ export class ClientUniverse {
if (targetChannel) {
await targetChannel.emitMessageLocally(clientUniverseMessage);
return {
messageStatus: 'ok'
messageStatus: 'ok',
};
} else {
return {
messageStatus: 'channel not found'
messageStatus: 'channel not found',
};
}
}
},
});
// add functions
@ -165,7 +165,7 @@ export class ClientUniverse {
await this.smartsocketClient.connect();
logger.log('info', 'universe client connected successfully');
await this.clientUniverseCache.channelMap.forEach(async clientUniverseChannelArg => {
await this.clientUniverseCache.channelMap.forEach(async (clientUniverseChannelArg) => {
await clientUniverseChannelArg.populateSubscriptionToServer();
});
}

8
ts/smartuniverse.classes.clientuniversechannel.ts
View File

@ -55,10 +55,10 @@ export class ClientUniverseChannel implements interfaces.IUniverseChannel {
*/
public subscribe(observingFunctionArg: (messageArg: ClientUniverseMessage<any>) => void) {
return this.subject.subscribe(
messageArg => {
(messageArg) => {
observingFunctionArg(messageArg);
},
error => console.log(error)
(error) => console.log(error)
);
}
@ -73,7 +73,7 @@ export class ClientUniverseChannel implements interfaces.IUniverseChannel {
interfaces.ISocketRequest_SubscribeChannel
>('subscribeChannel', {
name: this.name,
passphrase: this.passphrase
passphrase: this.passphrase,
});
this.status = response.subscriptionStatus;
}
@ -95,7 +95,7 @@ export class ClientUniverseChannel implements interfaces.IUniverseChannel {
passphrase: this.passphrase,
targetChannelName: this.name,
messageText: messageArg.messageText,
payload: messageArg.payload
payload: messageArg.payload,
};
await this.clientUniverseRef.smartsocketClient.serverCall(
'processMessage',

8
ts/smartuniverse.classes.reactionrequest.ts
View File

@ -64,16 +64,16 @@ export class ReactionRequest<T extends plugins.typedrequestInterfaces.ITypedRequ
typedRequestPayload: {
method: this.method,
request: requestDataArg,
response: null
}
response: null,
},
};
channel.sendMessage({
messageText: 'reactionRequest',
payload
payload,
});
}
plugins.smartdelay.delayFor(timeoutMillisArg).then(async () => {
await subscriptionMap.forEach(subscriptionArg => {
await subscriptionMap.forEach((subscriptionArg) => {
subscriptionArg.unsubscribe();
});
reactionResult.complete();

8
ts/smartuniverse.classes.reactionresponse.ts
View File

@ -28,7 +28,7 @@ export class ReactionResponse<T extends plugins.typedrequestInterfaces.ITypedReq
this.channels.addArray(optionsArg.channels);
this.funcDef = optionsArg.funcDef;
for (const channel of this.channels.getArray()) {
channel.subscribe(messageArg => {
channel.subscribe((messageArg) => {
this.processMessageForReaction(channel, messageArg);
});
}
@ -51,12 +51,12 @@ export class ReactionResponse<T extends plugins.typedrequestInterfaces.ITypedReq
...messageArg.payload,
typedRequestPayload: {
...messageArg.payload.typedRequestPayload,
response
}
response,
},
};
channelArg.sendMessage({
messageText: 'reactionResponse',
payload
payload,
});
}
}

4
ts/smartuniverse.classes.reactionresult.ts
View File

@ -7,7 +7,7 @@ export class ReactionResult<T extends plugins.typedrequestInterfaces.ITypedReque
private completeDeferred = plugins.smartpromise.defer<Array<T['response']>>();
constructor() {
this.resultSubscribe(responseArg => {
this.resultSubscribe((responseArg) => {
this.endResult.push(responseArg);
});
}
@ -29,7 +29,7 @@ export class ReactionResult<T extends plugins.typedrequestInterfaces.ITypedReque
*/
public async getFirstResult() {
const done = plugins.smartpromise.defer<T['response']>();
const subscription = this.resultReplaySubject.subscribe(result => {
const subscription = this.resultReplaySubject.subscribe((result) => {
done.resolve(result);
subscription.unsubscribe();
});

26
ts/smartuniverse.classes.universe.ts
View File

@ -70,7 +70,7 @@ export class Universe {
* returns a channel
*/
public getChannel(channelNameArg: string) {
return this.universeCache.channelMap.find(channelArg => {
return this.universeCache.channelMap.find((channelArg) => {
return channelArg.name === channelNameArg;
});
}
@ -87,7 +87,7 @@ export class Universe {
return `smartuniverse server ${this.getUniverseVersion()}`;
},
forceSsl: false,
port: portArg
port: portArg,
});
} else {
console.log('Universe is using externally supplied server');
@ -100,7 +100,7 @@ export class Universe {
// add a role for the clients
const ClientRole = new plugins.smartsocket.SocketRole({
name: 'UniverseClient',
passwordHash: plugins.smarthash.sha256FromStringSync('UniverseClient') // authentication happens on another level
passwordHash: plugins.smarthash.sha256FromStringSync('UniverseClient'), // authentication happens on another level
});
// add the role to smartsocket
@ -115,13 +115,13 @@ export class Universe {
const universeConnection = new UniverseConnection({
universe: this,
socketConnection: socketConnectionArg,
authenticationRequests: [dataArg]
authenticationRequests: [dataArg],
});
await UniverseConnection.addConnectionToCache(this, universeConnection);
return {
subscriptionStatus: 'subscribed'
subscriptionStatus: 'subscribed',
};
}
},
});
const socketFunctionProcessMessage = new plugins.smartsocket.SocketFunction({
@ -133,17 +133,11 @@ export class Universe {
socketConnectionArg
);
if (universeConnection) {
logger.log(
'ok',
'found UniverseConnection for socket for incoming message'
);
logger.log('ok', 'found UniverseConnection for socket for incoming message');
} else {
logger.log(
'warn',
'found no Authorized channel for incoming message'
);
logger.log('warn', 'found no Authorized channel for incoming message');
return {
error: 'You need to authenticate for a channel'
error: 'You need to authenticate for a channel',
};
}
const unauthenticatedMessage = UniverseMessage.createMessageFromPayload(
@ -158,7 +152,7 @@ export class Universe {
const authenticatedMessage = unauthenticatedMessage;
await this.universeCache.addMessage(authenticatedMessage);
}
}
},
});
// add socket functions

4
ts/smartuniverse.classes.universecache.ts
View File

@ -58,7 +58,7 @@ export class UniverseCache {
messageArg.setUniverseCache(this);
UniverseChannel.authorizeAMessageForAChannel(this, messageArg);
this.messageMap.add(messageArg);
messageArg.universeChannelList.forEach(universeChannel => {
messageArg.universeChannelList.forEach((universeChannel) => {
universeChannel.push(messageArg);
});
}
@ -71,7 +71,7 @@ export class UniverseCache {
channelName?: string
): Observable<UniverseMessage<any>> {
const messageObservable = from(this.messageMap.getArray()).pipe(
filter(messageArg => {
filter((messageArg) => {
return messageArg.smartTimestamp.isYoungerThanMilliSeconds(this.destructionTime);
})
);

16
ts/smartuniverse.classes.universechannel.ts
View File

@ -34,7 +34,7 @@ export class UniverseChannel {
* returns boolean wether certain channel exists
*/
public static async doesChannelExists(universeCacheArg: UniverseCache, channelNameArg: string) {
const channel = universeCacheArg.channelMap.find(channelArg => {
const channel = universeCacheArg.channelMap.find((channelArg) => {
return channelArg.name === channelNameArg;
});
if (channel) {
@ -55,7 +55,7 @@ export class UniverseChannel {
universeCacheArg: UniverseCache,
universeMessageArg: UniverseMessage<any>
): UniverseChannel {
const foundChannel = universeCacheArg.channelMap.find(universeChannel => {
const foundChannel = universeCacheArg.channelMap.find((universeChannel) => {
const result = universeChannel.authenticate(universeMessageArg);
return result;
});
@ -73,7 +73,7 @@ export class UniverseChannel {
}
public static getUniverseChannelByName(universeRef: Universe, universeChannelName: string) {
return universeRef.universeCache.channelMap.find(channelArg => {
return universeRef.universeCache.channelMap.find((channelArg) => {
return channelArg.name === universeChannelName;
});
}
@ -118,7 +118,7 @@ export class UniverseChannel {
public async push(messageArg: UniverseMessage<any>) {
this.subject.next(messageArg);
const universeConnectionsWithChannelAccess: UniverseConnection[] = [];
await this.universeRef.universeCache.connectionMap.forEach(async socketConnection => {
await this.universeRef.universeCache.connectionMap.forEach(async (socketConnection) => {
if (socketConnection.authenticatedChannels.includes(this)) {
universeConnectionsWithChannelAccess.push(socketConnection);
}
@ -132,7 +132,7 @@ export class UniverseChannel {
passphrase: messageArg.passphrase,
targetChannelName: this.name,
messageText: messageArg.messageText,
payload: messageArg.payload
payload: messageArg.payload,
};
smartsocket.clientCall(
'processMessage',
@ -145,10 +145,10 @@ export class UniverseChannel {
// functions to interact with a channel locally
public subscribe(observingFunctionArg: (messageArg: UniverseMessage<any>) => void) {
return this.subject.subscribe(
messageArg => {
(messageArg) => {
observingFunctionArg(messageArg);
},
error => console.log(error)
(error) => console.log(error)
);
}
@ -162,7 +162,7 @@ export class UniverseChannel {
payload: messageDescriptor.payload,
targetChannelName: this.name,
passphrase: this.passphrase,
timestamp: Date.now()
timestamp: Date.now(),
});
this.universeRef.universeCache.addMessage(messageToSend);
}

6
ts/smartuniverse.classes.universeconnection.ts
View File

@ -37,7 +37,7 @@ export class UniverseConnection {
universeConnectionArg: UniverseConnection
): Promise<UniverseConnection> {
let connectionToReturn: UniverseConnection;
universeCache.connectionMap.forEach(async existingConnection => {
universeCache.connectionMap.forEach(async (existingConnection) => {
if (existingConnection.socketConnection === universeConnectionArg.socketConnection) {
connectionToReturn = await this.mergeUniverseConnections(
existingConnection,
@ -87,7 +87,7 @@ export class UniverseConnection {
universeCache: UniverseCache,
socketConnectionArg: plugins.smartsocket.SocketConnection
): UniverseConnection {
const universeConnection = universeCache.connectionMap.find(universeConnectionArg => {
const universeConnection = universeCache.connectionMap.find((universeConnectionArg) => {
return universeConnectionArg.socketConnection === socketConnectionArg;
});
return universeConnection;
@ -124,7 +124,7 @@ export class UniverseConnection {
this.universeRef = optionsArg.universe;
this.authenticationRequests = optionsArg.authenticationRequests;
this.socketConnection = optionsArg.socketConnection;
this.socketConnection.eventSubject.subscribe(async eventArg => {
this.socketConnection.eventSubject.subscribe(async (eventArg) => {
switch (eventArg) {
case 'disconnected':
await this.disconnect('upstreamevent');

2
ts/smartuniverse.classes.universemessage.ts
View File

@ -81,7 +81,7 @@ export class UniverseMessage<T> implements interfaces.IUniverseMessage {
.then(async () => {
this.universeCache.messageMap.remove(this);
})
.catch(err => {
.catch((err) => {
console.log(err);
console.log(this);
});

2
ts/smartuniverse.plugins.ts
View File

@ -34,5 +34,5 @@ export {
smartrequest,
smartsocket,
smarttime,
smartunique
smartunique,
};