ignotum 0.0.7 → 0.0.9

package/src/dev-runtime/database.ts

@@ -47,6 +47,7 @@ import {
   SchemaDefinitionTypeId,
   type ValueDescriptor,
 } from "@ignotum/contracts/schema";
+import type { FileValue } from "@ignotum/contracts/schema/file";
 
 import { DevelopmentDatabase } from "./migrations.js";
 
@@ -59,6 +60,7 @@ type RuntimeDocumentValue =
   | number
   | string
   | Date
+  | FileValue
   | ReadonlyArray<RuntimeDocumentValue>
   | RuntimeObject;
 type RuntimeValue = RuntimeObject;
@@ -98,10 +100,18 @@ export interface LocalDatabaseReader {
 }
 
 export interface LocalDatabaseWriter extends LocalDatabaseReader {
-  readonly delete: (tableName: string, id: string) => Result<void, never>;
+  readonly delete: (tableName: string, id: string) => Result<void, DocumentNotFoundValue>;
   readonly insert: (tableName: string, value: RuntimeValue) => Result<GeneratedIdType, never>;
-  readonly patch: (tableName: string, id: string, value: RuntimeValue) => Result<void, never>;
-  readonly replace: (tableName: string, id: string, value: RuntimeValue) => Result<void, never>;
+  readonly patch: (
+    tableName: string,
+    id: string,
+    value: RuntimeValue,
+  ) => Result<void, DocumentNotFoundValue>;
+  readonly replace: (
+    tableName: string,
+    id: string,
+    value: RuntimeValue,
+  ) => Result<void, DocumentNotFoundValue>;
 }
 
 export interface LocalQueryContext {
@@ -722,11 +732,14 @@ export class LocalDatabase extends Context.Service<LocalDatabase, LocalDatabaseS
         id: string,
         invalidations: DependencyRecorder<WriteInvalidation>,
       ) {
-        const table = yield* resolveTable(schema, tableName);
+        const table = yield* resolveTable(schema, tableName).pipe(Effect.orDie);
         const documentId = GeneratedId.make(id);
-        const stored = yield* findStored({ id, tableId: table.id });
-        const keys = Option.isSome(stored) ? yield* indexKeys(table, stored.value) : [];
-        yield* sql`DELETE FROM documents WHERE id = ${id} AND tableId = ${table.id}`;
+        const stored = yield* findStored({ id, tableId: table.id }).pipe(Effect.orDie);
+        if (Option.isNone(stored)) return yield* Effect.fail(documentNotFound(tableName, id));
+        const keys = yield* indexKeys(table, stored.value).pipe(Effect.orDie);
+        yield* sql`DELETE FROM documents WHERE id = ${id} AND tableId = ${table.id}`.pipe(
+          Effect.orDie,
+        );
         invalidations.record(
           tableDependency(table.id),
           documentDependency(table.id, documentId),
@@ -741,32 +754,35 @@ export class LocalDatabase extends Context.Service<LocalDatabase, LocalDatabaseS
         value: RuntimeValue,
         invalidations: DependencyRecorder<WriteInvalidation>,
       ) {
-        const table = yield* resolveTable(schema, tableName);
+        const table = yield* resolveTable(schema, tableName).pipe(Effect.orDie);
         const documentId = GeneratedId.make(id);
-        const stored = yield* findStored({ id, tableId: table.id });
-        const oldKeys = Option.isSome(stored) ? yield* indexKeys(table, stored.value) : [];
-        let newKeys = oldKeys.slice(0, 0);
-        if (Option.isSome(stored)) {
-          const current = yield* decodeFields(table.definition, tableName, stored.value, "patch");
-          const fields = yield* encodeFields(
-            table.definition,
-            tableName,
-            { ...current, ...value },
-            "patch",
-            id,
-          );
-          const updatedAt = nextUpdatedAt(yield* DateTime.now, stored.value.updatedAt);
-          yield* sql`
-            UPDATE documents
-            SET fields = ${fields}, updatedAt = ${updatedAt}
-            WHERE id = ${id} AND tableId = ${table.id}
-          `;
-          newKeys = yield* writeIndexEntries(table, {
-            ...stored.value,
-            fields,
-            updatedAt,
-          });
-        }
+        const stored = yield* findStored({ id, tableId: table.id }).pipe(Effect.orDie);
+        if (Option.isNone(stored)) return yield* Effect.fail(documentNotFound(tableName, id));
+        const oldKeys = yield* indexKeys(table, stored.value).pipe(Effect.orDie);
+        const current = yield* decodeFields(
+          table.definition,
+          tableName,
+          stored.value,
+          "patch",
+        ).pipe(Effect.orDie);
+        const fields = yield* encodeFields(
+          table.definition,
+          tableName,
+          { ...current, ...value },
+          "patch",
+          id,
+        ).pipe(Effect.orDie);
+        const updatedAt = nextUpdatedAt(yield* DateTime.now, stored.value.updatedAt);
+        yield* sql`
+          UPDATE documents
+          SET fields = ${fields}, updatedAt = ${updatedAt}
+          WHERE id = ${id} AND tableId = ${table.id}
+        `.pipe(Effect.orDie);
+        const newKeys = yield* writeIndexEntries(table, {
+          ...stored.value,
+          fields,
+          updatedAt,
+        }).pipe(Effect.orDie);
         invalidations.record(
           tableDependency(table.id),
           documentDependency(table.id, documentId),
@@ -783,25 +799,25 @@ export class LocalDatabase extends Context.Service<LocalDatabase, LocalDatabaseS
         value: RuntimeValue,
         invalidations: DependencyRecorder<WriteInvalidation>,
       ) {
-        const table = yield* resolveTable(schema, tableName);
+        const table = yield* resolveTable(schema, tableName).pipe(Effect.orDie);
         const documentId = GeneratedId.make(id);
-        const stored = yield* findStored({ id, tableId: table.id });
-        const oldKeys = Option.isSome(stored) ? yield* indexKeys(table, stored.value) : [];
-        let newKeys = oldKeys.slice(0, 0);
-        if (Option.isSome(stored)) {
-          const fields = yield* encodeFields(table.definition, tableName, value, "replace", id);
-          const updatedAt = nextUpdatedAt(yield* DateTime.now, stored.value.updatedAt);
-          yield* sql`
-            UPDATE documents
-            SET fields = ${fields}, updatedAt = ${updatedAt}
-            WHERE id = ${id} AND tableId = ${table.id}
-          `;
-          newKeys = yield* writeIndexEntries(table, {
-            ...stored.value,
-            fields,
-            updatedAt,
-          });
-        }
+        const stored = yield* findStored({ id, tableId: table.id }).pipe(Effect.orDie);
+        if (Option.isNone(stored)) return yield* Effect.fail(documentNotFound(tableName, id));
+        const oldKeys = yield* indexKeys(table, stored.value).pipe(Effect.orDie);
+        const fields = yield* encodeFields(table.definition, tableName, value, "replace", id).pipe(
+          Effect.orDie,
+        );
+        const updatedAt = nextUpdatedAt(yield* DateTime.now, stored.value.updatedAt);
+        yield* sql`
+          UPDATE documents
+          SET fields = ${fields}, updatedAt = ${updatedAt}
+          WHERE id = ${id} AND tableId = ${table.id}
+        `.pipe(Effect.orDie);
+        const newKeys = yield* writeIndexEntries(table, {
+          ...stored.value,
+          fields,
+          updatedAt,
+        }).pipe(Effect.orDie);
         invalidations.record(
           tableDependency(table.id),
           documentDependency(table.id, documentId),
@@ -994,17 +1010,13 @@ export class LocalDatabase extends Context.Service<LocalDatabase, LocalDatabaseS
         return Object.freeze({
           ...reader,
           delete: (tableName: string, id: string) =>
-            resultFromEffect(
-              deleteDocument(schema, tableName, id, invalidations).pipe(Effect.orDie),
-            ),
+            resultFromEffect(deleteDocument(schema, tableName, id, invalidations)),
           insert: (tableName: string, value: RuntimeValue) =>
             resultFromEffect(insert(schema, tableName, value, invalidations).pipe(Effect.orDie)),
           patch: (tableName: string, id: string, value: RuntimeValue) =>
-            resultFromEffect(patch(schema, tableName, id, value, invalidations).pipe(Effect.orDie)),
+            resultFromEffect(patch(schema, tableName, id, value, invalidations)),
           replace: (tableName: string, id: string, value: RuntimeValue) =>
-            resultFromEffect(
-              replace(schema, tableName, id, value, invalidations).pipe(Effect.orDie),
-            ),
+            resultFromEffect(replace(schema, tableName, id, value, invalidations)),
         });
       };
 

package/src/dev-runtime/files.ts

@@ -0,0 +1,337 @@
+import { encodeCanonicalJson } from "@ignotum/contracts/json";
+import { validateApplicationFile } from "@ignotum/contracts/schema/file-content";
+import {
+  FileGrantToken,
+  FileId,
+  FileUploadToken,
+  RuntimeFileOccurrence,
+  encodedFileOccurrencesOf,
+  fileLimits,
+  type RuntimeFileMetadata,
+  type RuntimeFileOccurrence as RuntimeFileOccurrenceValue,
+} from "@ignotum/contracts/schema/file";
+import type { FunctionAddress, SubscriptionId } from "@ignotum/contracts/runtime/sync";
+import { fileGrantUrlPrefix, fileUploadUrlPrefix } from "@ignotum/contracts/runtime/transport";
+import type { InvocationId } from "@ignotum/contracts/runtime/identity";
+import { IdGenerator } from "@ignotum/shared/id";
+import { Context, Effect, FileSystem, Layer, Option, Path, Schema } from "effect";
+import { SqlClient } from "effect/unstable/sql";
+
+interface Preparation {
+  readonly function: FunctionAddress;
+  readonly args: Schema.Json;
+  readonly files: ReadonlyArray<RuntimeFileOccurrenceValue>;
+  readonly uploads: ReadonlyMap<FileId, FileUploadToken>;
+}
+
+interface Grant {
+  readonly subscriptionId: SubscriptionId;
+  readonly file: RuntimeFileMetadata;
+}
+
+const StoredFile = Schema.Struct({
+  fileId: FileId,
+  name: Schema.String,
+  format: RuntimeFileOccurrence.fields.file.fields.format,
+  size: Schema.Natural,
+  ready: Schema.Literals([0, 1]),
+});
+
+const StoredDocumentFields = Schema.Struct({ fields: Schema.String });
+const JsonObjectString = Schema.fromJsonString(Schema.JsonObject);
+
+interface LocalApplicationFilesService {
+  readonly prepare: (
+    invocationId: InvocationId,
+    functionAddress: FunctionAddress,
+    args: Schema.Json,
+    fileIds: ReadonlyArray<FileId>,
+  ) => Effect.Effect<ReadonlyArray<{ readonly id: FileId; readonly url?: string }>>;
+  readonly admit: (
+    invocationId: InvocationId,
+    functionAddress: FunctionAddress,
+    args: Schema.Json,
+  ) => Effect.Effect<ReadonlyArray<RuntimeFileOccurrenceValue>>;
+  readonly upload: (token: FileUploadToken, bytes: Uint8Array) => Effect.Effect<string>;
+  readonly grants: (
+    subscriptionId: SubscriptionId,
+    files: ReadonlyArray<RuntimeFileOccurrenceValue>,
+  ) => Effect.Effect<ReadonlyArray<{ readonly id: FileId; readonly url: string }>>;
+  readonly releaseGrants: (subscriptionId: SubscriptionId) => Effect.Effect<void>;
+  readonly readGrant: (
+    token: FileGrantToken,
+  ) => Effect.Effect<
+    Option.Option<{ readonly file: RuntimeFileMetadata; readonly bytes: Uint8Array }>
+  >;
+  readonly reconcile: Effect.Effect<void>;
+  readonly releasePreparation: (invocationId: InvocationId) => Effect.Effect<void>;
+}
+
+export const LocalApplicationFiles = Context.Reference<LocalApplicationFilesService>(
+  "ignotum/dev-runtime/files/LocalApplicationFiles",
+  {
+    defaultValue: () => ({
+      admit: (_invocationId, _functionAddress, args) =>
+        Effect.succeed(encodedFileOccurrencesOf(args)),
+      grants: (_subscriptionId, files) =>
+        Effect.succeed(
+          Array.from(new Set(files.map(({ file }) => file.id)), (id) => ({ id, url: "" })),
+        ),
+      prepare: (_invocationId, _functionAddress, _args, fileIds) =>
+        Effect.succeed(fileIds.map((id) => ({ id }))),
+      upload: () => Effect.die("Local application file storage is unavailable."),
+      releaseGrants: () => Effect.void,
+      readGrant: () => Effect.succeed(Option.none()),
+      reconcile: Effect.void,
+      releasePreparation: () => Effect.void,
+    }),
+  },
+);
+
+const sameFile = (left: RuntimeFileMetadata, right: RuntimeFileMetadata): boolean =>
+  left.id === right.id &&
+  left.format === right.format &&
+  left.name === right.name &&
+  left.size === right.size;
+
+const validFilename = (name: string): boolean => {
+  const bytes = new TextEncoder().encode(name).byteLength;
+  const hasControlCharacter = Array.from(name).some((character) => {
+    const codePoint = character.codePointAt(0) ?? 0;
+    return codePoint <= 0x1f || codePoint === 0x7f;
+  });
+  return (
+    bytes > 0 &&
+    bytes <= fileLimits.filenameBytes &&
+    !hasControlCharacter &&
+    !name.includes("/") &&
+    !name.includes("\\")
+  );
+};
+
+export const localApplicationFilesLayer = (appDirectory: string) =>
+  Layer.effect(
+    LocalApplicationFiles,
+    Effect.gen(function* () {
+      const ids = yield* IdGenerator;
+      const fileSystem = yield* FileSystem.FileSystem;
+      const path = yield* Path.Path;
+      const sql = yield* SqlClient.SqlClient;
+      const directory = path.join(appDirectory, ".ignotum", "files");
+      yield* fileSystem.makeDirectory(directory, { recursive: true }).pipe(Effect.orDie);
+      const preparations = new Map<InvocationId, Preparation>();
+      const uploadFiles = new Map<FileUploadToken, RuntimeFileMetadata>();
+      const grants = new Map<FileGrantToken, Grant>();
+      const objectPath = (fileId: FileId) => path.join(directory, fileId);
+
+      const prepare = Effect.fn("LocalApplicationFiles.prepare")(function* (
+        invocationId: InvocationId,
+        functionAddress: FunctionAddress,
+        args: Schema.Json,
+        fileIds: ReadonlyArray<FileId>,
+      ) {
+        if (fileIds.length === 0) throw new Error("A file preparation must contain a file ID.");
+        const selected = new Set(fileIds);
+        if (selected.size !== fileIds.length) {
+          throw new Error("A file preparation contains a duplicate file ID.");
+        }
+        const files = encodedFileOccurrencesOf(args).filter((occurrence) =>
+          selected.has(occurrence.file.id),
+        );
+        if (new Set(files.map((occurrence) => occurrence.file.id)).size !== selected.size) {
+          throw new Error("Prepared files do not match the mutation arguments.");
+        }
+        const existing = preparations.get(invocationId);
+        if (existing !== undefined) {
+          if (
+            existing.function !== functionAddress ||
+            encodeCanonicalJson(existing.args) !== encodeCanonicalJson(args) ||
+            encodeCanonicalJson(existing.files) !== encodeCanonicalJson(files)
+          ) {
+            throw new Error("The invocation ID already belongs to another file preparation.");
+          }
+          return fileIds.map((id) => {
+            const token = existing.uploads.get(id);
+            return token === undefined ? { id } : { id, url: `${fileUploadUrlPrefix}${token}` };
+          });
+        }
+        const distinct = new Map<FileId, RuntimeFileMetadata>();
+        for (const occurrence of files) {
+          if (!validFilename(occurrence.file.name)) {
+            throw new Error("Prepared files do not match the mutation arguments.");
+          }
+          const prior = distinct.get(occurrence.file.id);
+          if (prior !== undefined && !sameFile(prior, occurrence.file)) {
+            throw new Error("One file ID has conflicting metadata.");
+          }
+          distinct.set(occurrence.file.id, occurrence.file);
+        }
+        if (distinct.size > fileLimits.filesPerMutation) throw new Error("Too many files.");
+        const totalBytes = [...distinct.values()].reduce((total, file) => total + file.size, 0);
+        if (totalBytes > fileLimits.mutationBytes) throw new Error("File uploads are too large.");
+
+        const staged = yield* sql<{ readonly bytes: number }>`
+          SELECT COALESCE(SUM(size), 0) AS bytes FROM applicationFiles WHERE ready = 0
+        `;
+        let additionalStagedBytes = 0;
+        for (const file of distinct.values()) {
+          const rows = yield* sql<typeof StoredFile.Type>`
+            SELECT fileId, name, format, size, ready FROM applicationFiles WHERE fileId = ${file.id}
+          `;
+          const stored = rows[0];
+          if (stored === undefined) additionalStagedBytes += file.size;
+          else if (
+            !sameFile(
+              {
+                id: stored.fileId,
+                name: stored.name,
+                format: stored.format,
+                size: stored.size,
+              },
+              file,
+            )
+          ) {
+            throw new Error(`File '${file.id}' has conflicting metadata.`);
+          }
+        }
+        if ((staged[0]?.bytes ?? 0) + additionalStagedBytes > fileLimits.stagedBytesPerApp) {
+          throw new Error("The app has too many staged file bytes.");
+        }
+        const uploads = new Map<FileId, FileUploadToken>();
+        for (const file of distinct.values()) {
+          const rows = yield* sql<typeof StoredFile.Type>`
+            SELECT fileId, name, format, size, ready FROM applicationFiles WHERE fileId = ${file.id}
+          `;
+          const stored = rows[0];
+          if (stored !== undefined && stored.ready === 1) continue;
+          const token = yield* ids.generate(FileUploadToken);
+          uploads.set(file.id, token);
+          uploadFiles.set(token, file);
+          yield* sql`
+            INSERT INTO applicationFiles (fileId, name, format, size, ready)
+            VALUES (${file.id}, ${file.name}, ${file.format}, ${file.size}, 0)
+            ON CONFLICT(fileId) DO UPDATE SET
+              name = excluded.name, format = excluded.format, size = excluded.size
+          `;
+        }
+        preparations.set(invocationId, { function: functionAddress, args, files, uploads });
+        return fileIds.map((id) => {
+          const token = uploads.get(id);
+          return token === undefined ? { id } : { id, url: `${fileUploadUrlPrefix}${token}` };
+        });
+      });
+
+      const admit = Effect.fn("LocalApplicationFiles.admit")(function* (
+        invocationId: InvocationId,
+        functionAddress: FunctionAddress,
+        args: Schema.Json,
+      ) {
+        const preparation = preparations.get(invocationId);
+        if (
+          preparation !== undefined &&
+          (preparation.function !== functionAddress ||
+            encodeCanonicalJson(preparation.args) !== encodeCanonicalJson(args))
+        ) {
+          throw new Error("The mutation does not match its file preparation.");
+        }
+        for (const occurrence of preparation?.files ?? []) {
+          const rows = yield* sql<{ readonly ready: number }>`
+            SELECT ready FROM applicationFiles WHERE fileId = ${occurrence.file.id}
+          `;
+          if (rows[0]?.ready !== 1) throw new Error("A prepared file has not finished uploading.");
+        }
+        const occurrences = encodedFileOccurrencesOf(args);
+        for (const occurrence of occurrences) {
+          const rows = yield* sql<{ readonly ready: number }>`
+            SELECT ready FROM applicationFiles WHERE fileId = ${occurrence.file.id}
+          `;
+          if (rows[0]?.ready !== 1) throw new Error(`File '${occurrence.file.id}' is unavailable.`);
+        }
+        return occurrences;
+      });
+
+      const upload = Effect.fn("LocalApplicationFiles.upload")(function* (
+        token: FileUploadToken,
+        bytes: Uint8Array,
+      ) {
+        const file = uploadFiles.get(token);
+        if (file === undefined) throw new Error("The local file upload ticket is invalid.");
+        const validation = validateApplicationFile(bytes, file.format, file.size);
+        if (!validation.valid) throw new Error(validation.message);
+        yield* fileSystem.writeFile(objectPath(file.id), bytes).pipe(Effect.orDie);
+        yield* sql`UPDATE applicationFiles SET ready = 1 WHERE fileId = ${file.id}`;
+        uploadFiles.delete(token);
+        return "Stored";
+      });
+
+      const grantFiles = Effect.fn("LocalApplicationFiles.grants")(function* (
+        subscriptionId: SubscriptionId,
+        occurrences: ReadonlyArray<RuntimeFileOccurrenceValue>,
+      ) {
+        for (const [token, grant] of grants) {
+          if (grant.subscriptionId === subscriptionId) grants.delete(token);
+        }
+        const tokens = new Map<FileId, FileGrantToken>();
+        for (const occurrence of occurrences) {
+          if (tokens.has(occurrence.file.id)) continue;
+          const token = yield* ids.generate(FileGrantToken);
+          tokens.set(occurrence.file.id, token);
+          grants.set(token, { subscriptionId, file: occurrence.file });
+        }
+        return Array.from(tokens, ([id, token]) => ({
+          id,
+          url: `${fileGrantUrlPrefix}${token}`,
+        }));
+      });
+
+      const reconcile = Effect.gen(function* () {
+        const rows = yield* sql<typeof StoredDocumentFields.Type>`
+          SELECT fields FROM documents
+        `;
+        const referenced = new Set<FileId>();
+        for (const row of rows) {
+          const fields = yield* Schema.decodeEffect(JsonObjectString)(row.fields).pipe(
+            Effect.orDie,
+          );
+          for (const occurrence of encodedFileOccurrencesOf(fields))
+            referenced.add(occurrence.file.id);
+        }
+        const stored = yield* sql<typeof StoredFile.Type>`
+          SELECT fileId, name, format, size, ready FROM applicationFiles
+        `;
+        for (const file of stored) {
+          if (referenced.has(file.fileId)) continue;
+          yield* fileSystem.remove(objectPath(file.fileId), { force: true }).pipe(Effect.orDie);
+          yield* sql`DELETE FROM applicationFiles WHERE fileId = ${file.fileId}`;
+        }
+      });
+
+      return LocalApplicationFiles.of({
+        admit: (...args) => admit(...args).pipe(Effect.orDie),
+        grants: grantFiles,
+        readGrant: (token) => {
+          const grant = grants.get(token);
+          return grant === undefined
+            ? Effect.succeed(Option.none())
+            : fileSystem.readFile(objectPath(grant.file.id)).pipe(
+                Effect.orDie,
+                Effect.map((bytes) => Option.some({ file: grant.file, bytes })),
+              );
+        },
+        reconcile: reconcile.pipe(Effect.orDie),
+        releaseGrants: (subscriptionId) =>
+          Effect.sync(() => {
+            for (const [token, grant] of grants) {
+              if (grant.subscriptionId === subscriptionId) grants.delete(token);
+            }
+          }),
+        releasePreparation: (invocationId) =>
+          Effect.suspend(() => {
+            if (!preparations.delete(invocationId)) return Effect.void;
+            return reconcile.pipe(Effect.orDie);
+          }),
+        prepare: (...args) => prepare(...args).pipe(Effect.orDie),
+        upload: (...args) => upload(...args).pipe(Effect.orDie),
+      });
+    }),
+  );

package/src/dev-runtime/functions.ts

@@ -10,6 +10,7 @@ import { type RuntimeSchemaDefinition } from "@ignotum/contracts/runtime/schema"
 import { ErrorValueSchema, type ErrorValue } from "@ignotum/contracts/runtime/result";
 import { RequestId } from "@ignotum/contracts/runtime/id";
 import { IdGenerator } from "@ignotum/shared/id";
+import { encodedFileOccurrencesOf } from "@ignotum/contracts/schema/file";
 import type { RuntimeInvocationResult } from "@ignotum/contracts/runtime/hosted";
 import {
   FunctionAddress,
@@ -176,12 +177,19 @@ export class FunctionExecutor extends Context.Service<
             kind === "Query"
               ? database.trackedQueryTransaction(resolved.schema, invoke).pipe(
                   Effect.map(
-                    ({ dependencies, observedRevision, value }): RuntimeInvocationResult => ({
-                      type: "Query",
-                      result: value,
-                      dependencies,
-                      observedRevision,
-                    }),
+                    ({ dependencies, observedRevision, value }): RuntimeInvocationResult => {
+                      const files =
+                        value.type === "Success" && value.value !== undefined
+                          ? encodedFileOccurrencesOf(value.value)
+                          : [];
+                      const result = {
+                        type: "Query",
+                        result: value,
+                        dependencies,
+                        observedRevision,
+                      } as const;
+                      return files.length === 0 ? result : { ...result, files };
+                    },
                   ),
                 )
               : mutationSemaphore.withPermits(1)(

package/src/dev-runtime/migrations.ts

@@ -75,9 +75,23 @@ const addDevelopmentIndexes = Effect.gen(function* () {
   `;
 });
 
+const addApplicationFiles = Effect.gen(function* () {
+  const sql = yield* SqlClient.SqlClient;
+  yield* sql`
+    CREATE TABLE applicationFiles (
+      fileId TEXT PRIMARY KEY NOT NULL,
+      name TEXT NOT NULL,
+      format TEXT NOT NULL CHECK (format IN ('jpeg', 'png', 'webp', 'avif', 'gif')),
+      size INTEGER NOT NULL CHECK (size >= 0),
+      ready INTEGER NOT NULL DEFAULT 0 CHECK (ready IN (0, 1))
+    ) STRICT
+  `;
+});
+
 export const developmentMigrationLoader = Migrator.fromRecord({
   "0001_initial_development_schema": initialDevelopmentSchema,
   "0002_application_indexes": addDevelopmentIndexes,
+  "0003_application_files": addApplicationFiles,
 });
 
 interface DevelopmentDatabaseService {