@axium/server 0.36.6 → 0.37.0

package/dist/database.js

@@ -52,36 +52,26 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
 });
 import * as io from '@axium/core/node/io';
 import { plugins } from '@axium/core/plugins';
-import { Kysely, PostgresDialect, sql } from 'kysely';
+import { sql } from 'kysely';
 import { jsonObjectFrom } from 'kysely/helpers/postgres';
 import { randomBytes } from 'node:crypto';
 import { existsSync, readFileSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path/posix';
+import { join } from 'node:path';
 import { styleText } from 'node:util';
 import pg from 'pg';
 import * as z from 'zod';
 import config from './config.js';
-import rawSchema from './db.json' with { type: 'json' };
 import { dirs, systemDir } from './io.js';
+import { connect, database } from './db/connection.js';
+export { connect, database };
+import * as schema from './db/schema.js';
+export * as delta from './db/delta.js';
+export * as schema from './db/schema.js';
 pg.types.setTypeParser(pg.types.builtins.INT8, BigInt);
 // @ts-expect-error 2339
 BigInt.prototype.toJSON = function () {
     return Number(this);
 };
-const sym = Symbol.for('Axium:database');
-export let database;
-export function connect() {
-    if (database)
-        return database;
-    if (globalThis[sym])
-        return (database = globalThis[sym]);
-    database = new Kysely({
-        dialect: new PostgresDialect({ pool: new pg.Pool(config.db) }),
-    });
-    globalThis[sym] = database;
-    io.debug('Connected to database!');
-    return database;
-}
 // Helpers
 export async function count(...tables) {
     return await database
@@ -235,187 +225,6 @@ export async function init(opt) {
             await result_1;
     }
 }
-const numberTypes = [
-    'integer',
-    'int2',
-    'int4',
-    'int8',
-    'smallint',
-    'real',
-    'double precision',
-    'float4',
-    'float8',
-    'decimal',
-    'numeric',
-    'serial',
-];
-const bigintTypes = ['bigint', 'bigserial'];
-const booleanTypes = ['boolean', 'bool'];
-const stringTypes = ['varchar', 'char', 'text'];
-const dateTypes = ['date', 'datetime', 'time', 'timetz', 'timestamp', 'timestamptz'];
-const binaryTypes = ['binary', 'bytea', 'varbinary', 'blob'];
-const numericRangeTypes = ['int4range', 'numrange'];
-const stringRangeTypes = ['tsrange', 'tstzrange', 'daterange'];
-const multirangeTypes = ['int4multirange', 'int8multirange', 'nummultirange', 'tsmultirange', 'tstzmultirange', 'datemultirange'];
-const _primitive = z.literal([
-    ...numberTypes,
-    ...bigintTypes,
-    ...booleanTypes,
-    ...stringTypes,
-    ...dateTypes,
-    ...binaryTypes,
-    ...numericRangeTypes,
-    ...stringRangeTypes,
-    ...multirangeTypes,
-    'uuid',
-    'json',
-    'jsonb',
-]);
-const _ColumnType = z.union([
-    _primitive,
-    z.templateLiteral([
-        z.literal(['char', 'varchar', 'binary', 'varbinary', 'datetime', 'time', 'timetz', 'timestamp', 'timestamptz']),
-        '(',
-        z.int().nonnegative(),
-        ')',
-    ]),
-    z.templateLiteral([z.literal(['decimal', 'numeric']), '(', z.int().nonnegative(), z.literal([',', ', ']), z.int().nonnegative(), ')']),
-]);
-const ColumnType = z.union([_ColumnType, z.templateLiteral([_ColumnType, '[', z.int().nonnegative().optional(), ']'])]);
-export const Column = z.strictObject({
-    type: ColumnType,
-    required: z.boolean().default(false),
-    unique: z.boolean().default(false),
-    primary: z.boolean().default(false),
-    references: z.string().optional(),
-    onDelete: z.enum(['cascade', 'restrict', 'no action', 'set null', 'set default']).optional(),
-    default: z.any().optional(),
-    check: z.string().optional(),
-});
-export const Constraint = z.discriminatedUnion('type', [
-    z.strictObject({
-        type: z.literal('primary_key'),
-        on: z.string().array(),
-    }),
-    z.strictObject({
-        type: z.literal('foreign_key'),
-        on: z.string().array(),
-        target: z.string(),
-        references: z.string().array(),
-    }),
-    z.strictObject({
-        type: z.literal('unique'),
-        on: z.string().array(),
-        nulls_not_distinct: z.boolean().optional(),
-    }),
-    z.strictObject({
-        type: z.literal('check'),
-        check: z.string(),
-    }),
-]);
-export const Table = z.strictObject({
-    columns: z.record(z.string(), Column),
-    constraints: z.record(z.string(), Constraint).optional().default({}),
-});
-export const IndexString = z.templateLiteral([z.string(), ':', z.string()]);
-export function parseIndex(value) {
-    const [table, column] = value.split(':');
-    return { table, column };
-}
-export const SchemaDecl = z.strictObject({
-    tables: z.record(z.string(), Table),
-    indexes: IndexString.array().optional().default([]),
-});
-export const ColumnDelta = z.strictObject({
-    type: ColumnType.optional(),
-    default: z.string().optional(),
-    ops: z.literal(['drop_default', 'set_required', 'drop_required']).array().optional(),
-});
-export const TableDelta = z.strictObject({
-    add_columns: z.record(z.string(), Column).optional().default({}),
-    drop_columns: z.string().array().optional().default([]),
-    alter_columns: z.record(z.string(), ColumnDelta).optional().default({}),
-    add_constraints: z.record(z.string(), Constraint).optional().default({}),
-    drop_constraints: z.string().array().optional().default([]),
-});
-export const VersionDelta = z.strictObject({
-    delta: z.literal(true),
-    add_tables: z.record(z.string(), Table).optional().default({}),
-    drop_tables: z.string().array().optional().default([]),
-    alter_tables: z.record(z.string(), TableDelta).optional().default({}),
-    add_indexes: IndexString.array().optional().default([]),
-    drop_indexes: IndexString.array().optional().default([]),
-});
-export const SchemaFile = z.object({
-    format: z.literal(0),
-    versions: z.discriminatedUnion('delta', [SchemaDecl.extend({ delta: z.literal(false) }), VersionDelta]).array(),
-    /** List of tables to wipe */
-    wipe: z.string().array().optional().default([]),
-    /** Set the latest version, defaults to the last one */
-    latest: z.int32().nonnegative().optional(),
-    /** Maps tables to their ACL tables, e.g. `"storage": "acl.storage"` */
-    acl_tables: z.record(z.string(), z.string()).optional().default({}),
-});
-const { data, error } = SchemaFile.safeParse(rawSchema);
-if (error)
-    io.error('Invalid base database schema:\n' + z.prettifyError(error));
-const schema = data;
-export function* getSchemaFiles() {
-    yield ['@axium/server', schema];
-    for (const [name, plugin] of plugins) {
-        if (!plugin._db)
-            continue;
-        try {
-            yield [name, SchemaFile.parse(plugin._db)];
-        }
-        catch (e) {
-            throw `Invalid database configuration for plugin "${name}":\n${io.errorText(e)}`;
-        }
-    }
-}
-/**
- * Get the active schema
- */
-export function getFullSchema(opt = {}) {
-    const fullSchema = { tables: {}, indexes: [], versions: {} };
-    for (const [pluginName, file] of getSchemaFiles()) {
-        if (opt.exclude?.includes(pluginName))
-            continue;
-        file.latest ??= file.versions.length - 1;
-        let currentSchema = { tables: {}, indexes: [] };
-        fullSchema.versions[pluginName] = file.latest;
-        for (const [version, schema] of file.versions.entries()) {
-            if (!schema.delta)
-                currentSchema = schema;
-            else {
-                try {
-                    applyDeltaToSchema(currentSchema, schema);
-                }
-                catch (e) {
-                    throw `Failed to apply version ${version - 1}->${version} delta to ${pluginName}: ${io.errorText(e)}`;
-                }
-            }
-            if (version === file.latest)
-                break;
-        }
-        for (const name of Object.keys(currentSchema.tables)) {
-            if (name in fullSchema.tables)
-                throw 'Duplicate table name in database schema: ' + name;
-            fullSchema.tables[name] = currentSchema.tables[name];
-        }
-        for (const index of currentSchema.indexes) {
-            if (fullSchema.indexes.includes(index))
-                throw 'Duplicate index in database schema: ' + index;
-            fullSchema.indexes.push(index);
-        }
-    }
-    return fullSchema;
-}
-const schemaToIntrospected = {
-    boolean: 'bool',
-    integer: 'int4',
-    'text[]': '_text',
-};
 const VersionMap = z.record(z.string(), z.int32().nonnegative());
 export const UpgradesInfo = z.object({
     current: VersionMap.default({}),
@@ -430,364 +239,6 @@ export function getUpgradeInfo() {
 export function setUpgradeInfo(info) {
     io.writeJSON(upgradesFilePath, info);
 }
-export function applyTableDeltaToSchema(table, delta) {
-    for (const column of delta.drop_columns) {
-        if (column in table.columns)
-            delete table.columns[column];
-        else
-            throw `can't drop column ${column} because it does not exist`;
-    }
-    for (const [name, column] of Object.entries(delta.add_columns)) {
-        if (name in table.columns)
-            throw `can't add column ${name} because it already exists`;
-        table.columns[name] = column;
-    }
-    for (const [name, columnDelta] of Object.entries(delta.alter_columns)) {
-        const column = table.columns[name];
-        if (!column)
-            throw `can't modify column ${name} because it does not exist`;
-        if (columnDelta.type)
-            column.type = columnDelta.type;
-        if (columnDelta.default)
-            column.default = columnDelta.default;
-        for (const op of columnDelta.ops || []) {
-            switch (op) {
-                case 'drop_default':
-                    delete column.default;
-                    break;
-                case 'set_required':
-                    column.required = true;
-                    break;
-                case 'drop_required':
-                    column.required = false;
-                    break;
-            }
-        }
-    }
-    for (const name of delta.drop_constraints) {
-        if (table.constraints[name])
-            delete table.constraints[name];
-        else
-            throw `can't drop constraint ${name} because it does not exist`;
-    }
-    for (const [name, constraint] of Object.entries(delta.add_constraints)) {
-        if (table.constraints[name])
-            throw `can't add constraint ${name} because it already exists`;
-        table.constraints[name] = constraint;
-    }
-}
-export function applyDeltaToSchema(schema, delta) {
-    for (const tableName of delta.drop_tables) {
-        if (tableName in schema.tables)
-            delete schema.tables[tableName];
-        else
-            throw `can't drop table ${tableName} because it does not exist`;
-    }
-    for (const [tableName, table] of Object.entries(delta.add_tables)) {
-        if (tableName in schema.tables)
-            throw `can't add table ${tableName} because it already exists`;
-        else
-            schema.tables[tableName] = table;
-    }
-    for (const [tableName, tableDelta] of Object.entries(delta.alter_tables)) {
-        if (tableName in schema.tables)
-            applyTableDeltaToSchema(schema.tables[tableName], tableDelta);
-        else
-            throw `can't modify table ${tableName} because it does not exist`;
-    }
-}
-export function validateDelta(delta) {
-    const tableNames = [...Object.keys(delta.add_tables), ...Object.keys(delta.alter_tables), delta.drop_tables];
-    const uniqueTables = new Set(tableNames);
-    for (const table of uniqueTables) {
-        tableNames.splice(tableNames.indexOf(table), 1);
-    }
-    if (tableNames.length) {
-        throw `Duplicate table name(s): ${tableNames.join(', ')}`;
-    }
-    for (const [tableName, table] of Object.entries(delta.alter_tables)) {
-        const columnNames = [...Object.keys(table.add_columns), ...table.drop_columns];
-        const uniqueColumns = new Set(columnNames);
-        for (const column of uniqueColumns) {
-            columnNames.splice(columnNames.indexOf(column), 1);
-        }
-        if (columnNames.length) {
-            throw `Duplicate column name(s) in table ${tableName}: ${columnNames.join(', ')}`;
-        }
-    }
-}
-export function computeDelta(from, to) {
-    const fromTables = new Set(Object.keys(from.tables));
-    const toTables = new Set(Object.keys(to.tables));
-    const fromIndexes = new Set(from.indexes);
-    const toIndexes = new Set(to.indexes);
-    const add_tables = Object.fromEntries(toTables
-        .difference(fromTables)
-        .keys()
-        .map(name => [name, to.tables[name]]));
-    const alter_tables = {};
-    for (const name of fromTables.intersection(toTables)) {
-        const fromTable = from.tables[name], toTable = to.tables[name];
-        const fromColumns = new Set(Object.keys(fromTable));
-        const toColumns = new Set(Object.keys(toTable));
-        const drop_columns = fromColumns.difference(toColumns);
-        const add_columns = Object.fromEntries(toColumns
-            .difference(fromColumns)
-            .keys()
-            .map(colName => [colName, toTable.columns[colName]]));
-        const alter_columns = Object.fromEntries(toColumns
-            .intersection(fromColumns)
-            .keys()
-            .map(name => {
-            const fromCol = fromTable.columns[name], toCol = toTable.columns[name];
-            const alter = { ops: [] };
-            if ('default' in fromCol && !('default' in toCol))
-                alter.ops.push('drop_default');
-            else if (fromCol.default !== toCol.default)
-                alter.default = toCol.default;
-            if (fromCol.type != toCol.type)
-                alter.type = toCol.type;
-            if (fromCol.required != toCol.required)
-                alter.ops.push(toCol.required ? 'set_required' : 'drop_required');
-            return [name, alter];
-        }));
-        const fromConstraints = new Set(Object.keys(fromTable.constraints || {}));
-        const toConstraints = new Set(Object.keys(toTable.constraints || {}));
-        const drop_constraints = fromConstraints.difference(toConstraints);
-        const add_constraints = Object.fromEntries(toConstraints
-            .difference(fromConstraints)
-            .keys()
-            .map(constName => [constName, toTable.constraints[constName]]));
-        alter_tables[name] = {
-            add_columns,
-            drop_columns: Array.from(drop_columns),
-            alter_columns,
-            add_constraints,
-            drop_constraints: Array.from(drop_constraints),
-        };
-    }
-    return {
-        delta: true,
-        add_tables,
-        drop_tables: Array.from(fromTables.difference(toTables)),
-        alter_tables,
-        drop_indexes: Array.from(fromIndexes.difference(toIndexes)),
-        add_indexes: Array.from(toIndexes.difference(fromIndexes)),
-    };
-}
-export function collapseDeltas(deltas) {
-    const add_tables = {}, drop_tables = [], alter_tables = {}, add_indexes = [], drop_indexes = [];
-    for (const delta of deltas) {
-        validateDelta(delta);
-        for (const [name, table] of Object.entries(delta.alter_tables)) {
-            if (name in add_tables) {
-                applyTableDeltaToSchema(add_tables[name], table);
-            }
-            else if (name in alter_tables) {
-                const existing = alter_tables[name];
-                for (const [colName, column] of Object.entries(table.add_columns)) {
-                    existing.add_columns[colName] = column;
-                }
-                for (const colName of table.drop_columns) {
-                    if (colName in existing.add_columns)
-                        delete existing.add_columns[colName];
-                    else
-                        existing.drop_columns.push(colName);
-                }
-            }
-            else
-                alter_tables[name] = table;
-        }
-        for (const table of delta.drop_tables) {
-            if (table in add_tables)
-                delete add_tables[table];
-            else
-                drop_tables.push(table);
-        }
-        for (const [name, table] of Object.entries(delta.add_tables)) {
-            if (drop_tables.includes(name))
-                throw `Can't add and drop table "${name}" in the same change`;
-            if (name in alter_tables)
-                throw `Can't add and modify table "${name}" in the same change`;
-            add_tables[name] = table;
-        }
-        for (const index of delta.add_indexes) {
-            if (drop_indexes.includes(index))
-                throw `Can't add and drop index "${index}" in the same change`;
-            add_indexes.push(index);
-        }
-        for (const index of delta.drop_indexes) {
-            if (add_indexes.includes(index))
-                throw `Can't add and drop index "${index}" in the same change`;
-            drop_indexes.push(index);
-        }
-    }
-    return { delta: true, add_tables, drop_tables, alter_tables, add_indexes, drop_indexes };
-}
-export function deltaIsEmpty(delta) {
-    return (!Object.keys(delta.add_tables).length &&
-        !delta.drop_tables.length &&
-        !Object.keys(delta.alter_tables).length &&
-        !delta.add_indexes.length &&
-        !delta.drop_indexes.length);
-}
-const deltaColors = {
-    '+': 'green',
-    '-': 'red',
-    '*': 'white',
-};
-export function* displayDelta(delta) {
-    const tables = [
-        ...Object.keys(delta.add_tables).map(name => ({ op: '+', name })),
-        ...Object.entries(delta.alter_tables).map(([name, changes]) => ({ op: '*', name, changes })),
-        ...delta.drop_tables.map(name => ({ op: '-', name })),
-    ];
-    tables.sort((a, b) => a.name.localeCompare(b.name));
-    for (const table of tables) {
-        yield styleText(deltaColors[table.op], `${table.op} table ${table.name}`);
-        if (table.op != '*')
-            continue;
-        const columns = [
-            ...Object.keys(table.changes.add_columns).map(name => ({ op: '+', name })),
-            ...table.changes.drop_columns.map(name => ({ op: '-', name })),
-            ...Object.entries(table.changes.alter_columns).map(([name, changes]) => ({ op: '*', name, ...changes })),
-        ];
-        columns.sort((a, b) => a.name.localeCompare(b.name));
-        for (const column of columns) {
-            const columnChanges = column.op == '*'
-                ? [...(column.ops ?? []), 'default' in column && 'set_default', 'type' in column && 'set_type']
-                    .filter((e) => !!e)
-                    .map(e => e.replaceAll('_', ' '))
-                    .join(', ')
-                : null;
-            yield '\t' +
-                styleText(deltaColors[column.op], `${column.op} column ${column.name}${column.op != '*' ? '' : ': ' + columnChanges}`);
-        }
-        const constraints = [
-            ...Object.keys(table.changes.add_constraints).map(name => ({ op: '+', name })),
-            ...table.changes.drop_constraints.map(name => ({ op: '-', name })),
-        ];
-        for (const con of constraints) {
-            yield '\t' + styleText(deltaColors[con.op], `${con.op} constraint ${con.name}`);
-        }
-    }
-    const indexes = [
-        ...delta.add_indexes.map(raw => ({ op: '+', ...parseIndex(raw) })),
-        ...delta.drop_indexes.map(raw => ({ op: '-', ...parseIndex(raw) })),
-    ];
-    indexes.sort((a, b) => a.table.localeCompare(b.table) || a.column.localeCompare(b.column));
-    for (const index of indexes) {
-        yield styleText(deltaColors[index.op], `${index.op} index on ${index.table}.${index.column}`);
-    }
-}
-function columnFromSchema(column, allowPK) {
-    return function _addColumn(col) {
-        if (column.primary && allowPK)
-            col = col.primaryKey();
-        if (column.unique)
-            col = col.unique();
-        if (column.required)
-            col = col.notNull();
-        else if (column.unique)
-            col = col.nullsNotDistinct();
-        if (column.references)
-            col = col.references(column.references);
-        if (column.onDelete)
-            col = col.onDelete(column.onDelete);
-        if ('default' in column)
-            col = col.defaultTo(sql.raw(String(column.default)));
-        if (column.check)
-            col = col.check(sql.raw(column.check));
-        return col;
-    };
-}
-export async function applyDelta(delta, forceAbort = false) {
-    const tx = await database.startTransaction().execute();
-    try {
-        for (const [tableName, table] of Object.entries(delta.add_tables)) {
-            io.start('Adding table ' + tableName);
-            let query = tx.schema.createTable(tableName);
-            const columns = Object.entries(table.columns);
-            const pkColumns = columns.filter(([, column]) => column.primary).map(([name, column]) => ({ name, ...column }));
-            const needsSpecialConstraint = pkColumns.length > 1 || pkColumns.some(col => !col.required);
-            for (const [colName, column] of columns) {
-                query = query.addColumn(colName, sql.raw(column.type), columnFromSchema(column, !needsSpecialConstraint));
-            }
-            if (needsSpecialConstraint) {
-                query = query.addPrimaryKeyConstraint('PK_' + tableName.replaceAll('.', '_'), pkColumns.map(col => col.name));
-            }
-            await query.execute();
-            io.done();
-        }
-        for (const tableName of delta.drop_tables) {
-            io.start('Dropping table ' + tableName);
-            await tx.schema.dropTable(tableName).execute();
-            io.done();
-        }
-        for (const [tableName, tableDelta] of Object.entries(delta.alter_tables)) {
-            io.start(`Modifying table ${tableName}`);
-            const query = tx.schema.alterTable(tableName);
-            for (const constraint of tableDelta.drop_constraints) {
-                await query.dropConstraint(constraint).execute();
-            }
-            for (const colName of tableDelta.drop_columns) {
-                await query.dropColumn(colName).execute();
-            }
-            for (const [colName, column] of Object.entries(tableDelta.add_columns)) {
-                await query.addColumn(colName, sql.raw(column.type), columnFromSchema(column, false)).execute();
-            }
-            for (const [colName, column] of Object.entries(tableDelta.alter_columns)) {
-                if (column.default)
-                    await query.alterColumn(colName, col => col.setDefault(sql.raw(String(column.default)))).execute();
-                if (column.type)
-                    await query.alterColumn(colName, col => col.setDataType(sql.raw(column.type))).execute();
-                for (const op of column.ops ?? []) {
-                    switch (op) {
-                        case 'drop_default':
-                            if (column.default)
-                                throw 'Cannot set and drop default at the same time';
-                            await query.alterColumn(colName, col => col.dropDefault()).execute();
-                            break;
-                        case 'set_required':
-                            await query.alterColumn(colName, col => col.setNotNull()).execute();
-                            break;
-                        case 'drop_required':
-                            await query.alterColumn(colName, col => col.dropNotNull()).execute();
-                            break;
-                    }
-                }
-            }
-            for (const [name, con] of Object.entries(tableDelta.add_constraints)) {
-                switch (con.type) {
-                    case 'unique':
-                        await query.addUniqueConstraint(name, con.on, b => (con.nulls_not_distinct ? b.nullsNotDistinct() : b)).execute();
-                        break;
-                    case 'check':
-                        await query.addCheckConstraint(name, sql.raw(con.check)).execute();
-                        break;
-                    case 'foreign_key':
-                        await query.addForeignKeyConstraint(name, con.on, con.target, con.references, b => b).execute();
-                        break;
-                    case 'primary_key':
-                        await query.addPrimaryKeyConstraint(name, con.on).execute();
-                        break;
-                }
-            }
-            io.done();
-        }
-        if (forceAbort)
-            throw 'Rolling back due to --abort';
-        io.start('Committing');
-        await tx.commit().execute();
-        io.done();
-    }
-    catch (e) {
-        await tx.rollback().execute();
-        if (e instanceof SuppressedError)
-            io.error(e.suppressed);
-        throw e;
-    }
-}
 /**
  * Checks that a table has the expected column types, nullability, and default values.
  */
@@ -802,7 +253,7 @@ export async function checkTableTypes(tableName, types, opt, tableMetadata) {
     for (const [i, [key, { type, required = false, default: _default }]] of _types.entries()) {
         io.progress(i, _types.length, key);
         const col = columns[key];
-        const actualType = type in schemaToIntrospected ? schemaToIntrospected[type] : type;
+        const actualType = type in schema.toIntrospected ? schema.toIntrospected[type] : type;
         const hasDefault = _default !== undefined;
         try {
             if (!col)

package/dist/db/connection.d.ts

@@ -0,0 +1,5 @@
+import { Kysely } from 'kysely';
+import type { Schema } from '../database.js';
+export type Database = Kysely<Schema> & AsyncDisposable;
+export declare let database: Database;
+export declare function connect(): Database;

package/dist/db/connection.js

@@ -0,0 +1,18 @@
+import * as io from '@axium/core/node/io';
+import { Kysely, PostgresDialect } from 'kysely';
+import pg from 'pg';
+import config from '../config.js';
+const sym = Symbol.for('Axium:database');
+export let database;
+export function connect() {
+    if (database)
+        return database;
+    if (globalThis[sym])
+        return (database = globalThis[sym]);
+    database = new Kysely({
+        dialect: new PostgresDialect({ pool: new pg.Pool(config.db) }),
+    });
+    globalThis[sym] = database;
+    io.debug('Connected to database!');
+    return database;
+}