authored 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Mark Joseph Yalung
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+# Authored
+
+Session provider

package/index.d.ts

@@ -0,0 +1,60 @@
+import { Client } from "pg";
+export declare const $$: {
+    p: any;
+    textD: TextDecoder;
+};
+export declare const O: {
+    vals: {
+        <T>(o: {
+            [s: string]: T;
+        } | ArrayLike<T>): T[];
+        (o: {}): any[];
+    };
+    keys: {
+        (o: object): string[];
+        (o: {}): string[];
+    };
+    items: {
+        <T>(o: {
+            [s: string]: T;
+        } | ArrayLike<T>): [string, T][];
+        (o: {}): [string, any][];
+    };
+    has: (o: object, v: PropertyKey) => boolean;
+    define: <T>(o: T, p: PropertyKey, attributes: PropertyDescriptor & ThisType<any>) => T;
+    ass: {
+        <T extends {}, U>(target: T, source: U): T & U;
+        <T extends {}, U, V>(target: T, source1: U, source2: V): T & U & V;
+        <T extends {}, U, V, W>(target: T, source1: U, source2: V, source3: W): T & U & V & W;
+        (target: object, ...sources: any[]): any;
+    };
+    length: (ob: Object) => number;
+};
+type authConfig = {
+    COOKIE_NAME: string;
+    COOKIE_DOMAIN: string;
+    COOKIE_PATH: string;
+    COOKIE_HTTPONLY: boolean;
+    COOKIE_SECURE: boolean;
+    REFRESH_EACH_REQUEST: boolean;
+    COOKIE_SAMESITE: string;
+    KEY_PREFIX: string;
+    PERMANENT: boolean;
+    USE_SIGNER: boolean;
+    ID_LENGTH: number;
+    FILE_THRESHOLD: number;
+    LIFETIME: number;
+    MAX_COOKIE_SIZE: number;
+    INTERFACE: dbs;
+    STORAGE: string;
+    JWT_STORAGE: string;
+    JWT_LIFETIME: number;
+};
+type dbs = "fs" | "postgres";
+export declare class Auth {
+    postgresClient?: Client;
+    config: authConfig;
+    constructor(type: dbs);
+    initStorage(path?: string): void;
+}
+export {};

package/index.js

@@ -0,0 +1,216 @@
+import { randomBytes, createCipheriv, createDecipheriv } from "node:crypto";
+import { CryptoHasher } from "bun";
+export const $$ = {
+    set p(a) {
+        if (Array.isArray(a)) {
+            console.log(...a);
+        }
+        else {
+            console.log(a);
+        }
+    },
+    textD: new TextDecoder(),
+};
+export const O = {
+    vals: Object.values,
+    keys: Object.keys,
+    items: Object.entries,
+    has: Object.hasOwn,
+    define: Object.defineProperty,
+    ass: Object.assign,
+    length: (ob) => {
+        return Object.keys(ob).length;
+    },
+};
+export class Auth {
+    postgresClient;
+    config = {
+        COOKIE_NAME: "session",
+        COOKIE_DOMAIN: "127.0.0.1",
+        COOKIE_PATH: "/",
+        COOKIE_HTTPONLY: true,
+        COOKIE_SECURE: true,
+        REFRESH_EACH_REQUEST: false,
+        COOKIE_SAMESITE: "Strict",
+        KEY_PREFIX: "session:",
+        PERMANENT: true,
+        USE_SIGNER: false,
+        ID_LENGTH: 32,
+        FILE_THRESHOLD: 500,
+        LIFETIME: 31,
+        MAX_COOKIE_SIZE: 4093,
+        INTERFACE: "fs",
+        STORAGE: ".sessions",
+        JWT_STORAGE: ".jwt",
+        JWT_LIFETIME: 5,
+    };
+    constructor(type) {
+        this.config.INTERFACE = type;
+    }
+    initStorage(path = "./") {
+        this.config.STORAGE = path + this.config.STORAGE;
+        this.config.JWT_STORAGE = path + this.config.JWT_STORAGE;
+    }
+}
+class callBack {
+    data;
+    modified;
+    new = true;
+    length = 0;
+    constructor(initial = {}) {
+        this.modified = true;
+        this.data = {};
+        this.length = O.length(initial);
+        if (this.length) {
+            this.new = false;
+        }
+        O.ass(this.data, initial);
+    }
+    set(target, prop, val) {
+        if (!this.readonly && target.data[prop] != val) {
+            this.modified = true;
+            target.data[prop] = val;
+            if (!(prop in target.data)) {
+                this.length++;
+            }
+        }
+        return target;
+    }
+    get(target, prop) {
+        if (prop in target) {
+            return target[prop];
+        }
+        return target.data[prop];
+    }
+    has(target, prop) {
+        if (prop in target.data) {
+            return true;
+        }
+        return false;
+    }
+    deleteProperty(target, val) {
+        if (!this.readonly && val in target.data) {
+            this.modified = true;
+            delete target.data[val];
+        }
+        return true;
+    }
+}
+class ServerSide extends callBack {
+    modified;
+    sid;
+    readonly;
+    constructor(sid = "", initial = {}, readonly = false) {
+        super(initial);
+        this.modified = false;
+        this.sid = sid;
+        this.readonly = readonly;
+    }
+    get session() {
+        return new Proxy(this, this);
+    }
+}
+function hmacDigest(salt) {
+    const hmac = new Bun.CryptoHasher("sha256", salt);
+    return hmac.digest();
+}
+function str2Buffer(str) {
+    return Buffer.from(str);
+}
+function decode(str) {
+    return $$.textD.decode(str);
+}
+class Signator {
+    salt;
+    constructor(salt) {
+        this.salt = salt;
+    }
+    getSignature(val) {
+        const vals = str2Buffer(val);
+        return hmacDigest(this.salt).toString("base64");
+    }
+    deriveKey() {
+        return hmacDigest(this.salt);
+    }
+    sign(val) {
+        const sig = this.getSignature(val);
+        const vals = str2Buffer(val + "." + sig);
+        return decode(vals);
+    }
+    unsign(signedVal) {
+        if (!(signedVal.indexOf(".") > -1)) {
+            throw Error("No sep found");
+        }
+        const isept = signedVal.indexOf(".");
+        const val = signedVal.slice(0, isept);
+        const sig = signedVal.slice(isept + 1);
+        return this.verifySignature(val, sig);
+    }
+    loadUnsign(vals) {
+        if (this.unsign(vals)) {
+            const sval = str2Buffer(vals);
+            const sept = str2Buffer(".").toString()[0];
+            if (!(sept in sval)) {
+                throw Error("No sep found");
+            }
+            const isept = sval.indexOf(sept);
+            const val = sval.subarray(0, isept);
+            return Buffer.from(val.toString(), "base64").toString("utf-8");
+        }
+    }
+    verifySignature(val, sig) {
+        return this.getSignature(val) == sig ? true : false;
+    }
+    generate(len = 21) {
+        const rbyte = randomBytes(len);
+        let lbyte = rbyte.toString("base64");
+        if (lbyte.endsWith("=")) {
+            lbyte = lbyte.slice(0, -1);
+        }
+        return this.sign(lbyte);
+    }
+}
+class AuthInterface extends Signator {
+    constructor(salt) {
+        super(salt ?? "salty");
+    }
+    async openSession(sid) {
+        if (this.unsign(sid))
+            return await this.fetchSession(sid);
+        return this.new;
+    }
+    async fetchSession(sid) {
+        return this.new;
+    }
+    async saveSession() {
+        return;
+    }
+    get new() {
+        return new ServerSide(this.generate(), {}).session;
+    }
+    get readonly() {
+        return new ServerSide(this.generate(), {}, true).session;
+    }
+}
+const sk = "helloworld";
+const CH = new CryptoHasher("sha256");
+function dSecret() {
+    return CH.copy().update(sk).digest();
+}
+function encrypt(text) {
+    const secretKey = dSecret();
+    const iv = randomBytes(16);
+    const cipher = createCipheriv("aes-256-cbc", secretKey, iv);
+    let encrypted = cipher.update(text, "utf8", "hex");
+    encrypted += cipher.final("hex");
+    return `${iv.toString("hex")}:${encrypted}`;
+}
+function decrypt(encryptedData) {
+    const secretKey = dSecret();
+    const [ivHex, encryptedText] = encryptedData.split(":");
+    const iv = Buffer.from(ivHex, "hex");
+    const decipher = createDecipheriv("aes-256-cbc", secretKey, iv);
+    let decrypted = decipher.update(encryptedText, "hex", "utf8");
+    decrypted += decipher.final("utf8");
+    return decrypted;
+}

package/jsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    // Enable latest features
+    "lib": ["ESNext", "DOM"],
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "authored",
+  "version": "0.0.1",
+  "description": "authored",
+  "author": "Marky <markjotep@gmail.com>",
+  "license": "MIT",
+  "types": "./types/index.d.ts",
+  "main": "index.js",
+  "keywords": [
+    "ts",
+    "bun"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MARKjotep/authored.git"
+  },
+  "bugs": {
+    "url": "https://github.com/MARKjotep/authored/issues"
+  },
+  "homepage": "https://github.com/MARKjotep/authored#readme",
+  "scripts": {
+    "build": "tsc ; dist=../../DIST/authored/ ; cp -r package.json $dist ; cp -r ./types/types.d.ts $dist/types; bun install --cwd $dist; "
+  },
+  "dependencies": {
+    "jsonwebtoken": "^9.0.2",
+    "pg": "^8.13.1"
+  },
+  "devDependencies": {
+    "@types/jsonwebtoken": "^9.0.7",
+    "@types/pg": "^8.11.10",
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
+  }
+}

package/types/index.d.ts

@@ -0,0 +1,60 @@
+import { Client } from "pg";
+export declare const $$: {
+    p: any;
+    textD: TextDecoder;
+};
+export declare const O: {
+    vals: {
+        <T>(o: {
+            [s: string]: T;
+        } | ArrayLike<T>): T[];
+        (o: {}): any[];
+    };
+    keys: {
+        (o: object): string[];
+        (o: {}): string[];
+    };
+    items: {
+        <T>(o: {
+            [s: string]: T;
+        } | ArrayLike<T>): [string, T][];
+        (o: {}): [string, any][];
+    };
+    has: (o: object, v: PropertyKey) => boolean;
+    define: <T>(o: T, p: PropertyKey, attributes: PropertyDescriptor & ThisType<any>) => T;
+    ass: {
+        <T extends {}, U>(target: T, source: U): T & U;
+        <T extends {}, U, V>(target: T, source1: U, source2: V): T & U & V;
+        <T extends {}, U, V, W>(target: T, source1: U, source2: V, source3: W): T & U & V & W;
+        (target: object, ...sources: any[]): any;
+    };
+    length: (ob: Object) => number;
+};
+type authConfig = {
+    COOKIE_NAME: string;
+    COOKIE_DOMAIN: string;
+    COOKIE_PATH: string;
+    COOKIE_HTTPONLY: boolean;
+    COOKIE_SECURE: boolean;
+    REFRESH_EACH_REQUEST: boolean;
+    COOKIE_SAMESITE: string;
+    KEY_PREFIX: string;
+    PERMANENT: boolean;
+    USE_SIGNER: boolean;
+    ID_LENGTH: number;
+    FILE_THRESHOLD: number;
+    LIFETIME: number;
+    MAX_COOKIE_SIZE: number;
+    INTERFACE: dbs;
+    STORAGE: string;
+    JWT_STORAGE: string;
+    JWT_LIFETIME: number;
+};
+type dbs = "fs" | "postgres";
+export declare class Auth {
+    postgresClient?: Client;
+    config: authConfig;
+    constructor(type: dbs);
+    initStorage(path?: string): void;
+}
+export {};

package/types/types.d.ts

@@ -0,0 +1,6 @@
+// 
+
+
+interface obj<T> {
+    [Key: string]: T;
+  }