Files

import { getUploadUrl } from 'modelence/server';
import fs from 'fs/promises';

const { url, fields, filePath } = await getUploadUrl({
  filePath: 'photo.png',
  contentType: 'image/png',
  visibility: 'public',
});

const data = await fs.readFile('./photo.png');
const formData = new FormData();
for (const [key, value] of Object.entries(fields)) {
  formData.append(key, value);
}
formData.append('file', new Blob([data], { type: 'image/png' }));

await fetch(url, { method: 'POST', body: formData });

console.log(filePath); // e.g. 'public/photo.png'

import { getFileUrl } from 'modelence/server';

const { url } = await getFileUrl('public/photo.png');
console.log(url); // Permanent public URL

const { url: privateUrl } = await getFileUrl('private/report.pdf');
console.log(privateUrl); // Time-limited presigned URL

import { downloadFile } from 'modelence/server';

const { downloadUrl } = await downloadFile('private/report.pdf');
// Redirect the user to downloadUrl or fetch it server-side

import { deleteFile } from 'modelence/server';

await deleteFile('public/photo.png');
await deleteFile('private/report.pdf');

import { getUploadUrl } from 'modelence/server';

const { filePath } = await getUploadUrl({
  filePath: 'avatars/user-123.png',
  contentType: 'image/png',
  visibility: 'private',
});
// filePath === 'private/avatars/user-123.png'

const { url } = await getFileUrl(filePath);

import { Module, Store, schema, getUploadUrl, getFileUrl, deleteFile } from 'modelence/server';
import { ObjectId } from 'mongodb';

const dbDocuments = new Store('documents', {
  schema: {
    userId: schema.userId(),
    filePath: schema.string(),
    createdAt: schema.date(),
  },
});

export default new Module('documents', {
  stores: [dbDocuments],
  queries: {
    // Hand out a time-limited URL only for a document the caller owns.
    async getUrl({ documentId }, { user }) {
      if (!user) {
        throw new Error('Authentication required');
      }
      const doc = await dbDocuments.requireOne({
        _id: new ObjectId(documentId as string),
        userId: new ObjectId(user.id),
      });
      return getFileUrl(doc.filePath);
    },
  },
  mutations: {
    // Issue an upload URL for a path scoped to the caller, then record ownership.
    async requestUpload({ contentType }, { user }) {
      if (!user) {
        throw new Error('Authentication required');
      }
      const filePath = `private/users/${user.id}/${new ObjectId().toString()}`;
      const upload = await getUploadUrl({
        filePath,
        contentType: contentType as string,
        visibility: 'private',
      });
      await dbDocuments.insertOne({
        userId: new ObjectId(user.id),
        filePath,
        createdAt: new Date(),
      });
      return upload; // { url, fields, filePath } — the client POSTs the file to `url`
    },

    // Only the owner can delete.
    async remove({ documentId }, { user }) {
      if (!user) {
        throw new Error('Authentication required');
      }
      const doc = await dbDocuments.requireOne({
        _id: new ObjectId(documentId as string),
        userId: new ObjectId(user.id),
      });
      await deleteFile(doc.filePath);
      await dbDocuments.deleteOne({ _id: doc._id });
    },
  },
});