@axium/server 0.0.1 → 0.0.3

package/dist/config.d.ts

@@ -0,0 +1,270 @@
+import { type PartialRecursive } from 'utilium';
+import * as z from 'zod';
+export declare const Database: z.ZodObject<{
+    host: z.ZodString;
+    port: z.ZodNumber;
+    password: z.ZodString;
+    user: z.ZodString;
+    database: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    host: string;
+    port: number;
+    password: string;
+    user: string;
+    database: string;
+}, {
+    host: string;
+    port: number;
+    password: string;
+    user: string;
+    database: string;
+}>;
+export type Database = z.infer<typeof Database>;
+export declare const db: Database;
+export declare const Auth: z.ZodObject<{
+    credentials: z.ZodBoolean;
+    debug: z.ZodOptional<z.ZodBoolean>;
+    secret: z.ZodString;
+    secure_cookies: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    credentials: boolean;
+    secret: string;
+    secure_cookies: boolean;
+    debug?: boolean | undefined;
+}, {
+    credentials: boolean;
+    secret: string;
+    secure_cookies: boolean;
+    debug?: boolean | undefined;
+}>;
+export type Auth = z.infer<typeof Auth>;
+export declare const auth: Auth;
+export declare const Log: z.ZodObject<{
+    level: z.ZodEnum<["error", "warn", "notice", "info", "debug"]>;
+    console: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    level: "debug" | "error" | "warn" | "notice" | "info";
+    console: boolean;
+}, {
+    level: "debug" | "error" | "warn" | "notice" | "info";
+    console: boolean;
+}>;
+export type Log = z.infer<typeof Log>;
+export declare const log: Log;
+export declare const Config: z.ZodObject<{
+    auth: z.ZodObject<{
+        credentials: z.ZodOptional<z.ZodBoolean>;
+        debug: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+        secret: z.ZodOptional<z.ZodString>;
+        secure_cookies: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        credentials?: boolean | undefined;
+        debug?: boolean | undefined;
+        secret?: string | undefined;
+        secure_cookies?: boolean | undefined;
+    }, {
+        credentials?: boolean | undefined;
+        debug?: boolean | undefined;
+        secret?: string | undefined;
+        secure_cookies?: boolean | undefined;
+    }>;
+    debug: z.ZodBoolean;
+    db: z.ZodObject<{
+        host: z.ZodOptional<z.ZodString>;
+        port: z.ZodOptional<z.ZodNumber>;
+        password: z.ZodOptional<z.ZodString>;
+        user: z.ZodOptional<z.ZodString>;
+        database: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        host?: string | undefined;
+        port?: number | undefined;
+        password?: string | undefined;
+        user?: string | undefined;
+        database?: string | undefined;
+    }, {
+        host?: string | undefined;
+        port?: number | undefined;
+        password?: string | undefined;
+        user?: string | undefined;
+        database?: string | undefined;
+    }>;
+    log: z.ZodObject<{
+        level: z.ZodOptional<z.ZodEnum<["error", "warn", "notice", "info", "debug"]>>;
+        console: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        level?: "debug" | "error" | "warn" | "notice" | "info" | undefined;
+        console?: boolean | undefined;
+    }, {
+        level?: "debug" | "error" | "warn" | "notice" | "info" | undefined;
+        console?: boolean | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    debug: boolean;
+    auth: {
+        credentials?: boolean | undefined;
+        debug?: boolean | undefined;
+        secret?: string | undefined;
+        secure_cookies?: boolean | undefined;
+    };
+    db: {
+        host?: string | undefined;
+        port?: number | undefined;
+        password?: string | undefined;
+        user?: string | undefined;
+        database?: string | undefined;
+    };
+    log: {
+        level?: "debug" | "error" | "warn" | "notice" | "info" | undefined;
+        console?: boolean | undefined;
+    };
+}, {
+    debug: boolean;
+    auth: {
+        credentials?: boolean | undefined;
+        debug?: boolean | undefined;
+        secret?: string | undefined;
+        secure_cookies?: boolean | undefined;
+    };
+    db: {
+        host?: string | undefined;
+        port?: number | undefined;
+        password?: string | undefined;
+        user?: string | undefined;
+        database?: string | undefined;
+    };
+    log: {
+        level?: "debug" | "error" | "warn" | "notice" | "info" | undefined;
+        console?: boolean | undefined;
+    };
+}>;
+export declare const File: z.ZodObject<z.objectUtil.extendShape<{
+    auth: z.ZodOptional<z.ZodObject<{
+        credentials: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+        debug: z.ZodOptional<z.ZodOptional<z.ZodOptional<z.ZodBoolean>>>;
+        secret: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        secure_cookies: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+    }, "strip", z.ZodTypeAny, {
+        credentials?: boolean | undefined;
+        debug?: boolean | undefined;
+        secret?: string | undefined;
+        secure_cookies?: boolean | undefined;
+    }, {
+        credentials?: boolean | undefined;
+        debug?: boolean | undefined;
+        secret?: string | undefined;
+        secure_cookies?: boolean | undefined;
+    }>>;
+    debug: z.ZodOptional<z.ZodBoolean>;
+    db: z.ZodOptional<z.ZodObject<{
+        host: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        port: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+        password: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        user: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        database: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        host?: string | undefined;
+        port?: number | undefined;
+        password?: string | undefined;
+        user?: string | undefined;
+        database?: string | undefined;
+    }, {
+        host?: string | undefined;
+        port?: number | undefined;
+        password?: string | undefined;
+        user?: string | undefined;
+        database?: string | undefined;
+    }>>;
+    log: z.ZodOptional<z.ZodObject<{
+        level: z.ZodOptional<z.ZodOptional<z.ZodEnum<["error", "warn", "notice", "info", "debug"]>>>;
+        console: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+    }, "strip", z.ZodTypeAny, {
+        level?: "debug" | "error" | "warn" | "notice" | "info" | undefined;
+        console?: boolean | undefined;
+    }, {
+        level?: "debug" | "error" | "warn" | "notice" | "info" | undefined;
+        console?: boolean | undefined;
+    }>>;
+}, {
+    include: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}>, "strip", z.ZodTypeAny, {
+    debug?: boolean | undefined;
+    auth?: {
+        credentials?: boolean | undefined;
+        debug?: boolean | undefined;
+        secret?: string | undefined;
+        secure_cookies?: boolean | undefined;
+    } | undefined;
+    db?: {
+        host?: string | undefined;
+        port?: number | undefined;
+        password?: string | undefined;
+        user?: string | undefined;
+        database?: string | undefined;
+    } | undefined;
+    log?: {
+        level?: "debug" | "error" | "warn" | "notice" | "info" | undefined;
+        console?: boolean | undefined;
+    } | undefined;
+    include?: string[] | undefined;
+}, {
+    debug?: boolean | undefined;
+    auth?: {
+        credentials?: boolean | undefined;
+        debug?: boolean | undefined;
+        secret?: string | undefined;
+        secure_cookies?: boolean | undefined;
+    } | undefined;
+    db?: {
+        host?: string | undefined;
+        port?: number | undefined;
+        password?: string | undefined;
+        user?: string | undefined;
+        database?: string | undefined;
+    } | undefined;
+    log?: {
+        level?: "debug" | "error" | "warn" | "notice" | "info" | undefined;
+        console?: boolean | undefined;
+    } | undefined;
+    include?: string[] | undefined;
+}>;
+export type File = z.infer<typeof File>;
+export interface Config extends z.infer<typeof Config> {
+}
+export declare let debug: boolean;
+export declare function get(): Config;
+/**
+ * Update the current config
+ */
+export declare function set(config: PartialRecursive<Config>): void;
+export declare const files: Map<string, PartialRecursive<Config>>;
+export interface LoadOptions {
+    /**
+     * If enabled, the config file will be not be loaded if it does not match the schema.
+     */
+    strict?: boolean;
+    /**
+     * If enabled, the config file will be skipped if it does not exist.
+     */
+    optional?: boolean;
+    /**
+     * If `optional`, this function will be called with the error if the config file is invalid or can't be read.
+     */
+    onError?(error: Error): void;
+}
+/**
+ * Load the config from the provided path
+ */
+export declare function load(path: string, options?: LoadOptions): void;
+export declare function loadDefaults(): void;
+/**
+ * Update the current config and write the updated config to the appropriate file
+ */
+export declare function save(changed: PartialRecursive<Config>, global?: boolean): void;
+/**
+ * Update the current config and write the updated config to the provided path
+ */
+export declare function saveTo(path: string, changed: PartialRecursive<Config>): void;
+/**
+ * Find the path to the config file
+ */
+export declare function findPath(global: boolean): string;

package/dist/config.js

@@ -0,0 +1,122 @@
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+import { levelText } from 'logzen';
+import { readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path/posix';
+import { assignWithDefaults } from 'utilium';
+import * as z from 'zod';
+import { findDir, logger, output } from './io.js';
+export const Database = z.object({
+    host: z.string(),
+    port: z.number(),
+    password: z.string(),
+    user: z.string(),
+    database: z.string(),
+});
+export const db = {
+    host: process.env.PGHOST || 'localhost',
+    port: process.env.PGPORT && Number.isSafeInteger(parseInt(process.env.PGPORT)) ? parseInt(process.env.PGPORT) : 5432,
+    password: process.env.PGPASSWORD || '',
+    user: process.env.PGUSER || 'axium',
+    database: process.env.PGDATABASE || 'axium',
+};
+export const Auth = z.object({
+    credentials: z.boolean(),
+    debug: z.boolean().optional(),
+    secret: z.string(),
+    secure_cookies: z.boolean(),
+});
+export const auth = {
+    credentials: false,
+    secret: '',
+    secure_cookies: false,
+};
+export const Log = z.object({
+    level: z.enum(levelText),
+    console: z.boolean(),
+});
+export const log = {
+    level: 'info',
+    console: true,
+};
+export const Config = z.object({
+    auth: Auth.partial(),
+    debug: z.boolean(),
+    db: Database.partial(),
+    log: Log.partial(),
+});
+// config from file
+export const File = Config.deepPartial().extend({
+    include: z.array(z.string()).optional(),
+});
+export let debug = false;
+export function get() {
+    return {
+        auth,
+        db,
+        debug,
+        log,
+    };
+}
+/**
+ * Update the current config
+ */
+export function set(config) {
+    assignWithDefaults(auth, config.auth ?? {});
+    debug = config.debug ?? debug;
+    assignWithDefaults(db, config.db ?? {});
+    assignWithDefaults(log, config.log ?? {});
+    logger.detach(output);
+    if (log.console)
+        logger.attach(output, { output: log.level });
+}
+export const files = new Map();
+/**
+ * Load the config from the provided path
+ */
+export function load(path, options = {}) {
+    let json;
+    try {
+        json = JSON.parse(readFileSync(path, 'utf8'));
+    }
+    catch (e) {
+        if (!options.optional)
+            throw e;
+        logger.debug(`Skipping config at ${path} (${e.message})`);
+        return;
+    }
+    const config = options.strict ? File.parse(json) : json;
+    files.set(path, config);
+    set(config);
+    for (const include of config.include ?? [])
+        load(join(dirname(path), include), { optional: true });
+}
+export function loadDefaults() {
+    load(findPath(true), { optional: true });
+    load(findPath(false), { optional: true });
+}
+/**
+ * Update the current config and write the updated config to the appropriate file
+ */
+export function save(changed, global = false) {
+    saveTo(process.env.AXIUM_CONFIG ?? findPath(global), changed);
+}
+/**
+ * Update the current config and write the updated config to the provided path
+ */
+export function saveTo(path, changed) {
+    set(changed);
+    const config = files.get(path) ?? {};
+    Object.assign(config, { ...changed, db: { ...config.db, ...changed.db } });
+    logger.debug(`Wrote config to ${path}`);
+    writeFileSync(path, JSON.stringify(config));
+}
+/**
+ * Find the path to the config file
+ */
+export function findPath(global) {
+    if (process.env.AXIUM_CONFIG)
+        return process.env.AXIUM_CONFIG;
+    return join(findDir(global), 'config.json');
+}
+if (process.env.AXIUM_CONFIG)
+    load(process.env.AXIUM_CONFIG);

package/dist/database.d.ts

@@ -0,0 +1,80 @@
+import type { AdapterAccountType as db } from '@auth/core/adapters';
+import { Kysely, type GeneratedAlways } from 'kysely';
+import * as config from './config.js';
+export interface Schema {
+    User: {
+        id: GeneratedAlways<string>;
+        name: string | null;
+        email: string;
+        emailVerified: Date | null;
+        image: string | null;
+        password: string | null;
+        salt: string | null;
+    };
+    Account: {
+        id: GeneratedAlways<string>;
+        userId: string;
+        type: db;
+        provider: string;
+        providerAccountId: string;
+        refresh_token?: string;
+        access_token?: string;
+        expires_at?: number;
+        token_type?: Lowercase<string>;
+        scope?: string;
+        id_token?: string;
+        session_state: string | null;
+    };
+    Session: {
+        id: GeneratedAlways<string>;
+        userId: string;
+        sessionToken: string;
+        expires: Date;
+    };
+    VerificationToken: {
+        identifier: string;
+        token: string;
+        expires: Date;
+    };
+    Authenticator: {
+        credentialID: string;
+        userId: string;
+        providerAccountId: string;
+        credentialPublicKey: string;
+        counter: number;
+        credentialDeviceType: string;
+        credentialBackedUp: boolean;
+        transports: string | null;
+    };
+}
+export declare let database: Kysely<Schema> & AsyncDisposable;
+export declare function connect(): Kysely<Schema> & AsyncDisposable;
+export interface Stats {
+    users: number;
+    accounts: number;
+    sessions: number;
+}
+export declare function status(): Promise<Stats>;
+export declare function statusText(): Promise<string>;
+export type OpOutputState = 'done' | 'log' | 'warn' | 'error' | 'start';
+export type OpOutput = {
+    (state: 'done'): void;
+    (state: Exclude<OpOutputState, 'done'>, message: string): void;
+};
+export interface OpOptions {
+    timeout: number;
+    force: boolean;
+    output?: OpOutput;
+}
+export interface InitOptions extends OpOptions {
+    skip: boolean;
+}
+export declare function init(opt: InitOptions): Promise<config.Database>;
+/**
+ * Completely remove Axium from the database.
+ */
+export declare function uninstall(opt: OpOptions): Promise<void>;
+/**
+ * Removes all data from tables.
+ */
+export declare function wipe(opt: OpOptions): Promise<void>;