https://github.com/devnax/naxauth
https://github.com/devnax/naxauth
Last synced: about 1 year ago
JSON representation
- Host: GitHub
- URL: https://github.com/devnax/naxauth
- Owner: devnax
- Created: 2024-08-19T12:49:25.000Z (almost 2 years ago)
- Default Branch: main
- Last Pushed: 2024-12-11T05:53:20.000Z (over 1 year ago)
- Last Synced: 2025-01-22T00:41:21.690Z (over 1 year ago)
- Language: TypeScript
- Size: 109 KB
- Stars: 0
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: readme.md
Awesome Lists containing this project
README
## Server callbacks
```js
import Auth from 'naxauth/server'
Auth.AuthConfig({
secret: process.env.APP_SECRET,
brandName: "Your Brand Name",
mailConfig: {
service: 'gmail',
host: 'smtp.gmail.com',
auth: {
user: '',
pass: ''
},
defaultTemplateData: {
logo: "url"
}
},
async getRequestData(req) {
return {
authToken: req.cookies['authorization'],
userAgent: "",
body: req.body
}
},
async getUserData(email) {
return await User.find({email})
},
actions: {
signin: {
emailNotification: false,
},
signup: {
action: {
url: "http://localhost:3000",
},
async createUser({
requestData,
hashPassword
}) {
const body = requestData.body
const created = await User.create({
...body,
email: body.email,
password: hashPassword,
"firstname": body.firstname,
"status": "active",
"role": "admin"
})
return {
...created,
name: `${created.firstname} ${created.lastname}`,
email: created.email,
photo: created.photo
}
}
},
verify: {
async updateUser({
user,
requestData
}) {
await User.update({status: "active"}, {email: user.email})
},
},
forgotPassword: {
action: {
url: "http://localhost:3000"
}
},
resetPassword: {
async updateUser({
user,
hashPassword
}) {
await User.update({password: hashPassword}, {email: user.email})
},
}
}
})
app.post("/auth", async (req, res)=> {
const {data, message, status} = await Auth.getAuth(req)
const {data, message, status} = await Auth.signin(req)
const {data, message, status} = await Auth.signup(req)
const {data, message, status} = await Auth.verify(req)
const {data, message, status} = await Auth.forgotPassword(req)
const {data, message, status} = await Auth.resetPassword(req)
const {data, message, status} = await Auth.useAuth(req)
const type = req.headers['request-type']
const {data, message, status} = await Auth.AuthHandler(type, req)
res.status(status).json({data, message})
})
```
## Server configs reference
```js
import { SignOptions } from "jsonwebtoken";
import { MailOptions } from "nodemailer/lib/json-transport";
import SMTPTransport from "nodemailer/lib/smtp-transport";
import { EmailTemplateData } from "./emailTemplate";
export type TO = { [key: string]: any }
export type UserData = Omit & {
name: string;
email: string;
password: string;
photo?: string;
}
export type RequestData = {
authToken: string;
userAgent: string;
body: Partial> & {
email?: string;
password?: string;
token?: string;
};
}
type UserAndReqData = { user: User, requestData: RequestData }
import { SignOptions } from "jsonwebtoken";
import { MailOptions } from "nodemailer/lib/json-transport";
import SMTPTransport from "nodemailer/lib/smtp-transport";
import { EmailTemplateData } from "./emailTemplate";
export type TO = { [key: string]: any }
export type UserData = Omit & {
name: string;
email: string;
password: string;
photo?: string;
}
export type RequestData = {
authToken: string;
userAgent: string;
body: Partial> & {
email?: string;
password?: string;
token?: string;
};
}
type UserAndReqData = { user: User, requestData: RequestData }
export interface NaxAuthConfigProps {
brandName: string;
secret?: string;
jwtConfig?: SignOptions & {
expiresIn?: number
};
mailConfig?: {
defaultOptions?: MailOptions,
defaultTemplateData?: EmailTemplateData
} & SMTPTransport.Options;
getRequestData: (req: Req) => Promise>;
getUserData: (email: string) => Promise>;
getAuthData?: (ctx: UserAndReqData) => Promise>>;
actions?: {
signin?: {
emailNotification?: boolean;
expiresIn?: number;
messages?: { [type in "wrongEmail" | "wrongPassword" | "success"]: string };
checkUser?: (ctx: UserAndReqData) => Promise;
mail?: (ctx: UserAndReqData & { templateData: EmailTemplateData }) => Promise<{
data?: Partial,
options?: MailOptions;
}>
},
signup?: {
mailType?: "verificaion" | "normal",
expiresLinkIn?: number;
messages?: { [type in "exists" | "invalidPassword" | "success"]: string };
action?: {
url: string;
text?: string;
};
isVerified?: (ctx: UserAndReqData) => Promise;
createUser: (ctx: { requestData: RequestData, hashPassword: string }) => Promise>;
mail?: (ctx: UserAndReqData & { templateData: EmailTemplateData }) => Promise<{
data?: Partial,
options?: MailOptions;
}>
},
update?: {
emailNotification?: boolean,
messages?: { [type in "notFound" | "success"]: string };
updateUser: (ctx: UserAndReqData & { hashPassword: string | null }) => Promise>;
mail?: (ctx: UserAndReqData & { templateData: EmailTemplateData }) => Promise<{
data?: Partial,
options?: MailOptions;
}>
},
verify?: {
emailNotification?: boolean;
messages?: { [type in "exists" | "invalid" | "success"]: string };
updateUser: (ctx: { user: User, requestData: RequestData }) => Promise;
mail?: (ctx: UserAndReqData & { templateData: EmailTemplateData }) => Promise<{
data?: Partial,
options?: MailOptions;
}>
},
forgotPassword?: {
expiresLinkIn?: number;
messages?: { [type in "sent" | "invalidUser" | "success"]: string };
action: {
url: string;
text?: string;
};
mail?: (ctx: UserAndReqData & { templateData: EmailTemplateData }) => Promise<{
data?: Partial,
options?: MailOptions;
}>
},
resetPassword?: {
emailNotification?: boolean;
messages?: { [type in "expired" | "invalid" | "success"]: string };
updateUser: (ctx: UserAndReqData & { hashPassword: string }) => Promise;
mail?: (ctx: UserAndReqData & { templateData: EmailTemplateData }) => Promise<{
data?: Partial,
options?: MailOptions;
}>
}
}
}
```
## Client Config
```js
import Auth from 'naxauth/client'
Auth.NaxAuthConfig({
baseUrl: "http://localhost:3000/api/auth",
fetch: {
method: "POST"
},
actions: {
getAuth: {
path: "/"
},
signin: {
path: "/signin"
},
signup: {
},
forgotPassword: {
},
resetPassword: {
}
}
})
```
## Client callbacks
```js
import Auth from 'naxauth/client'
await Auth.signin({
email: "",
password: ""
})
const auth = await Auth.getAuth()
await Auth.signout()
await Auth.signup({})
await Auth.forgotPassword(email)
await Auth.resetPassword({token: "", password: ""})
const isLogin = await Auth.getAuthToken()
```
## Client configs reference
```js
export type TO = { [key: string]: any }
export type ActionCallbacks = {
onRequestStart?: () => string;
onRequestEnd?: (res: Response) => string;
onError?: (message: string) => void;
onSuccess?: (message: string) => void;
}
export type ActionType = ActionCallbacks & {
path?: string;
fetch?: RequestInit;
}
export interface AUTH_CONFIG_TYPE {
baseUrl: string;
fetch?: RequestInit;
tokenName?: string;
tokenPlacement?: "cookie" | "header",
actions?: {
getAuth?: ActionType,
signin?: ActionType,
signup?: ActionType,
verify?: ActionType,
forgotPassword?: ActionType,
resetPassword?: ActionType
}
}
```
## Client Event
```ts
import Auth from 'naxauth/client'
export type EventNames =
"getAuth" |
"signin" |
"signup" |
"signout" |
"verify" |
"forgotPassword" |
"resetPassword" |
"signout" |
"success" |
"error" |
"requestStart" |
"requestEnd"
Auth.on(eventName, callback)
Auth.off(eventName, callback)
Auth.emit(eventName)
```
## React
```jsx
import {AuthProvider, useAuth} from 'naxauth/react'
const AuthView = () => {
const auth = useAuth()
if(auth.loading) return "loading..."
return
{auth.name}
{auth.email}
{auth.photo}
}
const App = () => {
return (
)
}
```