@axium/storage 0.1.0

package/LICENSE.md

@@ -0,0 +1,157 @@
+# GNU LESSER GENERAL PUBLIC LICENSE
+
+Version 3, 29 June 2007
+
+Copyright (C) 2007 Free Software Foundation, Inc.
+<https://fsf.org/>
+
+Everyone is permitted to copy and distribute verbatim copies of this
+license document, but changing it is not allowed.
+
+This version of the GNU Lesser General Public License incorporates the
+terms and conditions of version 3 of the GNU General Public License,
+supplemented by the additional permissions listed below.
+
+## 0. Additional Definitions.
+
+As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the
+GNU General Public License.
+
+"The Library" refers to a covered work governed by this License, other
+than an Application or a Combined Work as defined below.
+
+An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+A "Combined Work" is a work produced by combining or linking an
+Application with the Library. The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+## 1. Exception to Section 3 of the GNU GPL.
+
+You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+## 2. Conveying Modified Versions.
+
+If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+-   a) under this License, provided that you make a good faith effort
+    to ensure that, in the event an Application does not supply the
+    function or data, the facility still operates, and performs
+    whatever part of its purpose remains meaningful, or
+-   b) under the GNU GPL, with none of the additional permissions of
+    this License applicable to that copy.
+
+## 3. Object Code Incorporating Material from Library Header Files.
+
+The object code form of an Application may incorporate material from a
+header file that is part of the Library. You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+-   a) Give prominent notice with each copy of the object code that
+    the Library is used in it and that the Library and its use are
+    covered by this License.
+-   b) Accompany the object code with a copy of the GNU GPL and this
+    license document.
+
+## 4. Combined Works.
+
+You may convey a Combined Work under terms of your choice that, taken
+together, effectively do not restrict modification of the portions of
+the Library contained in the Combined Work and reverse engineering for
+debugging such modifications, if you also do each of the following:
+
+-   a) Give prominent notice with each copy of the Combined Work that
+    the Library is used in it and that the Library and its use are
+    covered by this License.
+-   b) Accompany the Combined Work with a copy of the GNU GPL and this
+    license document.
+-   c) For a Combined Work that displays copyright notices during
+    execution, include the copyright notice for the Library among
+    these notices, as well as a reference directing the user to the
+    copies of the GNU GPL and this license document.
+-   d) Do one of the following:
+    -   0) Convey the Minimal Corresponding Source under the terms of
+        this License, and the Corresponding Application Code in a form
+        suitable for, and under terms that permit, the user to
+        recombine or relink the Application with a modified version of
+        the Linked Version to produce a modified Combined Work, in the
+        manner specified by section 6 of the GNU GPL for conveying
+        Corresponding Source.
+    -   1) Use a suitable shared library mechanism for linking with
+        the Library. A suitable mechanism is one that (a) uses at run
+        time a copy of the Library already present on the user's
+        computer system, and (b) will operate properly with a modified
+        version of the Library that is interface-compatible with the
+        Linked Version.
+-   e) Provide Installation Information, but only if you would
+    otherwise be required to provide such information under section 6
+    of the GNU GPL, and only to the extent that such information is
+    necessary to install and execute a modified version of the
+    Combined Work produced by recombining or relinking the Application
+    with a modified version of the Linked Version. (If you use option
+    4d0, the Installation Information must accompany the Minimal
+    Corresponding Source and Corresponding Application Code. If you
+    use option 4d1, you must provide the Installation Information in
+    the manner specified by section 6 of the GNU GPL for conveying
+    Corresponding Source.)
+
+## 5. Combined Libraries.
+
+You may place library facilities that are a work based on the Library
+side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+-   a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities, conveyed under the terms of this License.
+-   b) Give prominent notice with the combined library that part of it
+    is a work based on the Library, and explaining where to find the
+    accompanying uncombined form of the same work.
+
+## 6. Revised Versions of the GNU Lesser General Public License.
+
+The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number. If the Library
+as you received it specifies that a certain numbered version of the
+GNU Lesser General Public License "or any later version" applies to
+it, you have the option of following the terms and conditions either
+of that published version or of any later version published by the
+Free Software Foundation. If the Library as you received it does not
+specify a version number of the GNU Lesser General Public License, you
+may choose any version of the GNU Lesser General Public License ever
+published by the Free Software Foundation.
+
+If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

package/README.md

@@ -0,0 +1,17 @@
+# Axium Storage
+
+This is a plugin for allowing users to store data on an Axium server.
+
+## Usage
+
+Update the configuration to include the files data directory:
+
+```json
+{
+	"storage": {
+		"data": "/path/to/storage/data"
+	}
+}
+```
+
+Also, make sure to run `axium plugin init @axium/storage` to add the necessary database tables for the plugin.

package/dist/client.d.ts

@@ -0,0 +1,15 @@
+import type { StorageItemMetadata, StorageItemUpdate, UserFilesInfo } from './common.js';
+import type { ItemSelection } from './selection.js';
+export declare function uploadItem(file: File): Promise<StorageItemMetadata>;
+export declare function updateItem(fileId: string, data: Blob): Promise<StorageItemMetadata>;
+export declare function getItemMetadata(fileId: string): Promise<StorageItemMetadata>;
+export declare function getDirectoryMetadata(parentId: string): Promise<StorageItemMetadata[]>;
+export declare function downloadItem(fileId: string): Promise<Blob>;
+export declare function updateItemMetadata(fileId: string, metadata: StorageItemUpdate): Promise<StorageItemMetadata>;
+export declare function deleteItem(fileId: string): Promise<StorageItemMetadata>;
+export declare function getUserFiles(userId: string): Promise<UserFilesInfo>;
+export interface _Sidebar {
+    selection: ItemSelection<string, StorageItemMetadata>;
+    items: StorageItemMetadata[];
+    getDirectory(id: string, assignTo?: StorageItemMetadata[]): Promise<StorageItemMetadata[]>;
+}

package/dist/client.js

@@ -0,0 +1,63 @@
+import { fetchAPI, token } from '@axium/client/requests';
+async function _upload(method, url, data) {
+    const init = {
+        method,
+        headers: {
+            'Content-Type': data.type,
+            'Content-Length': data.size.toString(),
+        },
+        body: data,
+    };
+    if (data instanceof File)
+        init.headers['X-Name'] = data.name;
+    if (token)
+        init.headers.Authorization = 'Bearer ' + token;
+    const response = await fetch(url, init);
+    if (!response.headers.get('Content-Type')?.includes('application/json')) {
+        throw new Error(`Unexpected response type: ${response.headers.get('Content-Type')}`);
+    }
+    const json = await response.json().catch(() => ({ message: 'Unknown server error (invalid JSON response)' }));
+    if (!response.ok)
+        throw new Error(json.message);
+    json.modifiedAt = new Date(json.modifiedAt);
+    return json;
+}
+export async function uploadItem(file) {
+    return _upload('PUT', '/raw/storage', file);
+}
+export async function updateItem(fileId, data) {
+    return _upload('POST', '/raw/storage/' + fileId, data);
+}
+export async function getItemMetadata(fileId) {
+    const result = await fetchAPI('GET', 'storage/item/:id', undefined, fileId);
+    result.modifiedAt = new Date(result.modifiedAt);
+    return result;
+}
+export async function getDirectoryMetadata(parentId) {
+    const result = await fetchAPI('GET', 'storage/directory/:id', undefined, parentId);
+    for (const item of result) {
+        item.modifiedAt = new Date(item.modifiedAt);
+    }
+    return result;
+}
+export async function downloadItem(fileId) {
+    const response = await fetch('/raw/storage/' + fileId, {
+        headers: token ? { Authorization: 'Bearer ' + token } : {},
+    });
+    if (!response.ok)
+        throw new Error('Failed to download files: ' + response.statusText);
+    return await response.blob();
+}
+export async function updateItemMetadata(fileId, metadata) {
+    return fetchAPI('PATCH', 'storage/item/:id', metadata, fileId);
+}
+export async function deleteItem(fileId) {
+    return fetchAPI('DELETE', 'storage/item/:id', undefined, fileId);
+}
+export async function getUserFiles(userId) {
+    const result = await fetchAPI('GET', 'users/:id/storage', undefined, userId);
+    for (const item of result.items) {
+        item.modifiedAt = new Date(item.modifiedAt);
+    }
+    return result;
+}

package/dist/common.d.ts

@@ -0,0 +1,65 @@
+import * as z from 'zod';
+declare module '@axium/core/api' {
+    interface _apiTypes {
+        'users/:id/storage': {
+            OPTIONS: {
+                usage: StorageUsage;
+                limits: StorageLimits;
+            };
+            GET: UserFilesInfo;
+        };
+        'storage/item/:id': {
+            GET: StorageItemMetadata;
+            DELETE: StorageItemMetadata;
+            PATCH: [z.input<typeof StorageItemUpdate>, StorageItemMetadata];
+        };
+        'storage/directory/:id': {
+            GET: StorageItemMetadata[];
+        };
+    }
+}
+export interface StorageLimits {
+    /** The maximum size per item in MB */
+    item_size: number;
+    /** Maximum number of items per user */
+    user_items: number;
+    /** The maximum storage size per user in MB */
+    user_size: number;
+}
+export interface StorageUsage {
+    bytes: number;
+    items: number;
+}
+export interface UserFilesInfo {
+    items: StorageItemMetadata[];
+    limits: StorageLimits;
+    usage: StorageUsage;
+}
+/**
+ * An update to file metadata.
+ */
+export declare const StorageItemUpdate: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    owner: z.ZodOptional<z.ZodUUID>;
+    trash: z.ZodOptional<z.ZodBoolean>;
+    restrict: z.ZodOptional<z.ZodBoolean>;
+    visibility: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type StorageItemUpdate = z.infer<typeof StorageItemUpdate>;
+export interface StorageItemMetadata {
+    createdAt: Date;
+    dataURL?: string;
+    hash: string;
+    id: string;
+    immutable: boolean;
+    modifiedAt: Date;
+    name: string | null;
+    userId: string;
+    parentId: string | null;
+    /** Whether editing the file is restricted to the owner */
+    restricted: boolean;
+    size: number;
+    trashedAt: Date | null;
+    type: string;
+    visibility: number;
+}

package/dist/common.js

@@ -0,0 +1,13 @@
+import * as z from 'zod';
+/**
+ * An update to file metadata.
+ */
+export const StorageItemUpdate = z
+    .object({
+    name: z.string(),
+    owner: z.uuid(),
+    trash: z.boolean(),
+    restrict: z.boolean(),
+    visibility: z.boolean(),
+})
+    .partial();

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from './common.js';

package/dist/index.js

@@ -0,0 +1 @@
+export * from './common.js';

package/dist/plugin.d.ts

@@ -0,0 +1,57 @@
+import type { Database, InitOptions, OpOptions } from '@axium/server/database';
+import './common.js';
+import './server.js';
+declare function statusText(): Promise<string>;
+declare function db_init(opt: InitOptions, db: Database): Promise<void>;
+declare function db_wipe(opt: OpOptions, db: Database): Promise<void>;
+declare function remove(opt: OpOptions, db: Database): Promise<void>;
+declare function clean(opt: OpOptions, db: Database): Promise<void>;
+declare const _default: {
+    statusText: typeof statusText;
+    hooks: {
+        db_init: typeof db_init;
+        db_wipe: typeof db_wipe;
+        remove: typeof remove;
+        clean: typeof clean;
+    };
+    name: string;
+    version: string;
+    author: string;
+    description: string;
+    funding: {
+        type: string;
+        url: string;
+    };
+    license: string;
+    repository: {
+        type: string;
+        url: string;
+    };
+    homepage: string;
+    bugs: {
+        url: string;
+    };
+    type: string;
+    main: string;
+    types: string;
+    exports: {
+        ".": string;
+        "./*": string;
+    };
+    files: string[];
+    scripts: {
+        build: string;
+    };
+    peerDependencies: {
+        "@axium/client": string;
+        "@axium/core": string;
+        "@axium/server": string;
+        "@sveltejs/kit": string;
+        utilium: string;
+    };
+    dependencies: {
+        blakejs: string;
+        zod: string;
+    };
+};
+export default _default;

package/dist/plugin.js

@@ -0,0 +1,62 @@
+import config from '@axium/server/config';
+import { count, database, warnExists } from '@axium/server/database';
+import { done, start } from '@axium/server/io';
+import { sql } from 'kysely';
+import pkg from '../package.json' with { type: 'json' };
+import './common.js';
+import './server.js';
+import { formatBytes } from '@axium/core/format';
+async function statusText() {
+    const items = await count('storage');
+    const { size } = await database
+        .selectFrom('storage')
+        .select(eb => eb.fn.sum('size').as('size'))
+        .executeTakeFirstOrThrow();
+    return `${items} items totaling ${formatBytes(Number(size))}`;
+}
+async function db_init(opt, db) {
+    start('Creating table storage');
+    await db.schema
+        .createTable('storage')
+        .addColumn('id', 'uuid', col => col.primaryKey().defaultTo(sql `gen_random_uuid()`))
+        .addColumn('userId', 'uuid', col => col.notNull().references('users.id').onDelete('cascade').onUpdate('cascade'))
+        .addColumn('parentId', 'uuid', col => col.references('storage.itemId').onDelete('cascade').onUpdate('cascade').defaultTo(null))
+        .addColumn('createdAt', 'timestamptz', col => col.notNull().defaultTo(sql `now()`))
+        .addColumn('modifiedAt', 'timestamptz', col => col.notNull().defaultTo(sql `now()`))
+        .addColumn('restricted', 'boolean', col => col.notNull().defaultTo(false))
+        .addColumn('size', 'integer', col => col.notNull())
+        .addColumn('trashedAt', 'timestamptz', col => col.defaultTo(null))
+        .addColumn('hash', 'bytea', col => col.notNull())
+        .addColumn('name', 'text', col => col.defaultTo(null))
+        .addColumn('type', 'text', col => col.notNull())
+        .addColumn('immutable', 'boolean', col => col.notNull())
+        .addColumn('visibility', 'integer', col => col.notNull().defaultTo(0))
+        .execute()
+        .then(done)
+        .catch(warnExists);
+}
+async function db_wipe(opt, db) {
+    start('Removing data from user storage');
+    await db.deleteFrom('storage').execute();
+    done();
+}
+async function remove(opt, db) {
+    start('Dropping table storage');
+    await db.schema.dropTable('storage').execute();
+    done();
+}
+async function clean(opt, db) {
+    start('Removing expired trash items');
+    const nDaysAgo = new Date(Date.now() - 86400000 * config.storage.trash_duration);
+    await db
+        .deleteFrom('storage')
+        .where('trashedAt', 'is not', null)
+        .where('trashedAt', '<', nDaysAgo)
+        .executeTakeFirstOrThrow()
+        .then(done);
+}
+export default {
+    ...pkg,
+    statusText,
+    hooks: { db_init, db_wipe, remove, clean },
+};

package/dist/polyfills.d.ts

@@ -0,0 +1,62 @@
+/**
+See:
+https://developer.mozilla.org/Web/JavaScript/Reference/Global_Objects/Uint8Array/toBase64
+https://developer.mozilla.org/Web/JavaScript/Reference/Global_Objects/Uint8Array/toHex
+https://github.com/microsoft/TypeScript/pull/61696
+https://github.com/microsoft/TypeScript/issues/61695
+
+@todo Remove when TypeScript 5.9 is released
+*/
+declare global {
+    interface Uint8ArrayConstructor {
+        /**
+         * Creates a new `Uint8Array` from a base64-encoded string.
+         * @param string The base64-encoded string.
+         * @param options If provided, specifies the alphabet and handling of the last chunk.
+         * @returns A new `Uint8Array` instance.
+         * @throws {SyntaxError} If the input string contains characters outside the specified alphabet, or if the last
+         * chunk is inconsistent with the `lastChunkHandling` option.
+         */
+        fromBase64: (string: string) => Uint8Array;
+        /**
+         * Creates a new `Uint8Array` from a base16-encoded string.
+         * @returns A new `Uint8Array` instance.
+         */
+        fromHex: (string: string) => Uint8Array;
+    }
+    interface Uint8Array<TArrayBuffer extends ArrayBufferLike> {
+        /**
+         * Converts the `Uint8Array` to a base64-encoded string.
+         * @param options If provided, sets the alphabet and padding behavior used.
+         * @returns A base64-encoded string.
+         */
+        toBase64: () => string;
+        /**
+         * Sets the `Uint8Array` from a base64-encoded string.
+         * @param string The base64-encoded string.
+         * @param options If provided, specifies the alphabet and handling of the last chunk.
+         * @returns An object containing the number of bytes read and written.
+         * @throws {SyntaxError} If the input string contains characters outside the specified alphabet, or if the last
+         * chunk is inconsistent with the `lastChunkHandling` option.
+         */
+        setFromBase64?: (string: string) => {
+            read: number;
+            written: number;
+        };
+        /**
+         * Converts the `Uint8Array` to a base16-encoded string.
+         * @returns A base16-encoded string.
+         */
+        toHex: () => string;
+        /**
+         * Sets the `Uint8Array` from a base16-encoded string.
+         * @param string The base16-encoded string.
+         * @returns An object containing the number of bytes read and written.
+         */
+        setFromHex?: (string: string) => {
+            read: number;
+            written: number;
+        };
+    }
+}
+export {};

package/dist/polyfills.js

@@ -0,0 +1,24 @@
+/**
+See:
+https://developer.mozilla.org/Web/JavaScript/Reference/Global_Objects/Uint8Array/toBase64
+https://developer.mozilla.org/Web/JavaScript/Reference/Global_Objects/Uint8Array/toHex
+https://github.com/microsoft/TypeScript/pull/61696
+https://github.com/microsoft/TypeScript/issues/61695
+
+@todo Remove when TypeScript 5.9 is released
+*/
+import { output } from '@axium/server/io';
+Uint8Array.prototype.toHex ??=
+    (output.warn('Using a polyfill of Uint8Array.prototype.toHex'),
+        function toHex() {
+            return [...this].map(b => b.toString(16).padStart(2, '0')).join('');
+        });
+Uint8Array.fromHex ??=
+    (output.warn('Using a polyfill of Uint8Array.fromHex'),
+        function fromHex(hex) {
+            const bytes = new Uint8Array(hex.length / 2);
+            for (let i = 0; i < hex.length; i += 2) {
+                bytes[i / 2] = parseInt(hex.slice(i, i + 2), 16);
+            }
+            return bytes;
+        });

package/dist/selection.d.ts

@@ -0,0 +1,17 @@
+import { SvelteSet } from 'svelte/reactivity';
+export declare class ItemSelection<T, V extends {
+    id: T;
+}> extends SvelteSet<T> {
+    /**
+     * The list of items that can be selected.
+     */
+    items: V[];
+    constructor(
+    /**
+     * The list of items that can be selected.
+     */
+    items: V[]);
+    last?: T;
+    toggle(id: T): boolean;
+    toggleRange(id: T): void;
+}

package/dist/selection.js

@@ -0,0 +1,32 @@
+import { SvelteSet } from 'svelte/reactivity';
+export class ItemSelection extends SvelteSet {
+    items;
+    constructor(
+    /**
+     * The list of items that can be selected.
+     */
+    items) {
+        super([]);
+        this.items = items;
+    }
+    last;
+    toggle(id) {
+        const has = this.has(id);
+        if (has)
+            this.delete(id);
+        else {
+            this.add(id);
+            this.last = id;
+        }
+        return has;
+    }
+    toggleRange(id) {
+        const from = this.items.findIndex(item => item.id === this.last);
+        const until = this.items.findIndex(item => item.id === id);
+        if (from === -1 || until === -1)
+            return;
+        const range = this.items.slice(Math.min(from, until), Math.max(from, until) + 1);
+        for (const item of range)
+            this.toggle(item.id);
+    }
+}

package/dist/server.d.ts

@@ -0,0 +1,61 @@
+import type { Generated } from 'kysely';
+import type { StorageItemMetadata, StorageLimits, StorageUsage } from './common.js';
+import './polyfills.js';
+declare module '@axium/server/database' {
+    interface Schema {
+        storage: {
+            createdAt: Generated<Date>;
+            hash: Uint8Array;
+            id: Generated<string>;
+            immutable: Generated<boolean>;
+            modifiedAt: Generated<Date>;
+            name: string | null;
+            parentId: string | null;
+            restricted: Generated<boolean>;
+            size: number;
+            trashedAt: Date | null;
+            type: string;
+            userId: string;
+            visibility: Generated<number>;
+        };
+    }
+}
+declare module '@axium/server/config' {
+    interface Config {
+        storage: {
+            /** Whether the storage API endpoints are enabled */
+            enabled: boolean;
+            /** Whether the files app is enabled. Requires `enabled` */
+            app_enabled: boolean;
+            /** Path to data directory */
+            data: string;
+            /** How many days files are kept in the trash */
+            trash_duration: number;
+            /** Default limits */
+            limits: StorageLimits;
+            /** Content Addressable Storage (CAS) configuration */
+            cas: {
+                /** Whether to use CAS */
+                enabled: boolean;
+                /** Mime types to include when determining if CAS should be used */
+                include: string[];
+                /** Mime types to exclude when determining if CAS should be used */
+                exclude: string[];
+            };
+        };
+    }
+}
+export interface StorageItem extends StorageItemMetadata {
+    data: Uint8Array<ArrayBufferLike>;
+}
+/**
+ * Returns the current usage of the storage for a user in bytes.
+ */
+export declare function currentUsage(userId: string): Promise<StorageUsage>;
+export declare function get(itemId: string): Promise<StorageItemMetadata>;
+export type ExternalLimitHandler = (userId?: string) => StorageLimits | Promise<StorageLimits>;
+/**
+ * Define the handler to get limits for a user externally.
+ */
+export declare function useLimits(handler: ExternalLimitHandler): void;
+export declare function getLimits(userId?: string): Promise<StorageLimits>;