@digimuza/saas-core 0.0.2

package/dist/db/schema/features.d.ts

@@ -0,0 +1,243 @@
+/**
+ * Who an override applies to, ordered from least to most specific.
+ *
+ * `global` is every application sharing this database; `application` narrows to
+ * one product built on the core. The distinction exists because this package is
+ * explicitly meant to back several SaaS products — without it, turning a flag on
+ * for one would turn it on for all of them.
+ */
+export declare const featureFlagScope: import("drizzle-orm/pg-core").PgEnum<["global", "application", "workspace", "user"]>;
+/**
+ * Resolution order. The **last** match wins, so the most specific override does.
+ *
+ * Exported because the service and its tests must agree on it, and because a
+ * caller debugging "why is this on for me" needs to know the order.
+ */
+export declare const FLAG_SCOPE_PRECEDENCE: readonly ["global", "application", "workspace", "user"];
+/**
+ * One override of one flag at one scope.
+ *
+ * A row is an *override*, not a definition. The flag itself — its key, its
+ * default, its permitted variants — is declared in code with
+ * `defineFeatureFlags`, so a typo is a compile error and a fresh database
+ * behaves the same as a configured one. This table only records deviations.
+ */
+export declare const featureFlags: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "feature_flags";
+    schema: undefined;
+    columns: {
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "feature_flags";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "feature_flags";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "feature_flags";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        key: import("drizzle-orm/pg-core").PgColumn<{
+            name: "key";
+            tableName: "feature_flags";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        scope: import("drizzle-orm/pg-core").PgColumn<{
+            name: "scope";
+            tableName: "feature_flags";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "application" | "global" | "user" | "workspace";
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["global", "application", "workspace", "user"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        application: import("drizzle-orm/pg-core").PgColumn<{
+            name: "application";
+            tableName: "feature_flags";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        workspaceId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "workspace_id";
+            tableName: "feature_flags";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        userId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "user_id";
+            tableName: "feature_flags";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        enabled: import("drizzle-orm/pg-core").PgColumn<{
+            name: "enabled";
+            tableName: "feature_flags";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        variant: import("drizzle-orm/pg-core").PgColumn<{
+            name: "variant";
+            tableName: "feature_flags";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        rolloutPercentage: import("drizzle-orm/pg-core").PgColumn<{
+            name: "rollout_percentage";
+            tableName: "feature_flags";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        description: import("drizzle-orm/pg-core").PgColumn<{
+            name: "description";
+            tableName: "feature_flags";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: 'pg';
+}>;
+export declare const featureFlagsRelations: import("drizzle-orm").Relations<"feature_flags", {
+    workspace: import("drizzle-orm").One<"workspaces", false>;
+    user: import("drizzle-orm").One<"users", false>;
+}>;
+export type FeatureFlagRow = typeof featureFlags.$inferSelect;
+export type NewFeatureFlagRow = typeof featureFlags.$inferInsert;
+export type FeatureFlagScope = (typeof featureFlagScope.enumValues)[number];
+//# sourceMappingURL=features.d.ts.map

package/dist/db/schema/features.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"features.d.ts","sourceRoot":"","sources":["../../../src/db/schema/features.ts"],"names":[],"mappings":"AAgBA;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,sFAK3B,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,YAAI,QAAQ,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,CAAU,CAAC;AAE7F;;;;;;;GAOG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyDxB,CAAC;AAEF,eAAO,MAAM,qBAAqB;;;EAM/B,CAAC;AAEJ,MAAM,MAAM,cAAc,GAAG,OAAO,YAAY,CAAC,YAAY,CAAC;AAC9D,MAAM,MAAM,iBAAiB,GAAG,OAAO,YAAY,CAAC,YAAY,CAAC;AACjE,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,gBAAgB,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC"}

package/dist/db/schema/features.js

@@ -0,0 +1,87 @@
+import { relations } from "drizzle-orm";
+import { boolean, index, integer, pgEnum, pgTable, text, unique, uuid, } from "drizzle-orm/pg-core";
+import { primaryId, timestamps } from "./_shared.js";
+import { users } from "./users.js";
+import { workspaces } from "./workspaces.js";
+/**
+ * Who an override applies to, ordered from least to most specific.
+ *
+ * `global` is every application sharing this database; `application` narrows to
+ * one product built on the core. The distinction exists because this package is
+ * explicitly meant to back several SaaS products — without it, turning a flag on
+ * for one would turn it on for all of them.
+ */
+export const featureFlagScope = pgEnum("feature_flag_scope", [
+    "global",
+    "application",
+    "workspace",
+    "user",
+]);
+/**
+ * Resolution order. The **last** match wins, so the most specific override does.
+ *
+ * Exported because the service and its tests must agree on it, and because a
+ * caller debugging "why is this on for me" needs to know the order.
+ */
+export const FLAG_SCOPE_PRECEDENCE = ["global", "application", "workspace", "user"];
+/**
+ * One override of one flag at one scope.
+ *
+ * A row is an *override*, not a definition. The flag itself — its key, its
+ * default, its permitted variants — is declared in code with
+ * `defineFeatureFlags`, so a typo is a compile error and a fresh database
+ * behaves the same as a configured one. This table only records deviations.
+ */
+export const featureFlags = pgTable("feature_flags", {
+    id: primaryId(),
+    /** Registry key, e.g. `"new-editor"`. */
+    key: text("key").notNull(),
+    scope: featureFlagScope("scope").notNull(),
+    /**
+     * Target, exactly one of which is set — matching `scope`. Kept as separate
+     * typed columns rather than a single polymorphic id so the workspace and user
+     * references are real foreign keys: an override for a deleted tenant is dead
+     * configuration that would otherwise accumulate forever.
+     */
+    application: text("application"),
+    workspaceId: uuid("workspace_id").references(() => workspaces.id, { onDelete: "cascade" }),
+    userId: uuid("user_id").references(() => users.id, { onDelete: "cascade" }),
+    enabled: boolean("enabled").notNull(),
+    /** A/B variant. Validated against the registry's declared variants on write. */
+    variant: text("variant"),
+    /**
+     * Percentage of subjects the flag is on for, 0-100. Null means "everyone this
+     * override applies to".
+     *
+     * Bucketing is a hash of key and subject id, so a given subject stays on the
+     * same side across requests and deploys — a flag that flickered per request
+     * would be worse than no flag.
+     */
+    rolloutPercentage: integer("rollout_percentage"),
+    description: text("description"),
+    ...timestamps,
+}, (table) => [
+    /**
+     * One override per flag per target.
+     *
+     * `nullsNotDistinct` is load-bearing: PostgreSQL treats NULLs as distinct in a
+     * unique index by default, so without it every global override — where all
+     * three target columns are null — would be considered unique and you could
+     * insert the same one endlessly.
+     */
+    unique("feature_flags_target_unique")
+        .on(table.key, table.scope, table.application, table.workspaceId, table.userId)
+        .nullsNotDistinct(),
+    /** The evaluation query: every override that could apply to one subject. */
+    index("feature_flags_key_scope_idx").on(table.key, table.scope),
+    index("feature_flags_workspace_idx").on(table.workspaceId),
+    index("feature_flags_user_idx").on(table.userId),
+]);
+export const featureFlagsRelations = relations(featureFlags, ({ one }) => ({
+    workspace: one(workspaces, {
+        fields: [featureFlags.workspaceId],
+        references: [workspaces.id],
+    }),
+    user: one(users, { fields: [featureFlags.userId], references: [users.id] }),
+}));
+//# sourceMappingURL=features.js.map

package/dist/db/schema/features.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features.js","sourceRoot":"","sources":["../../../src/db/schema/features.ts"],"names":[],"mappings":"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"}

package/dist/db/schema/files.d.ts

@@ -0,0 +1,253 @@
+/**
+ * Upload lifecycle.
+ *
+ * `pending` exists because of direct browser uploads: the server issues a
+ * presigned URL and the client sends the bytes out-of-band, so the row has to be
+ * created *before* anything is stored. Until the upload is confirmed against the
+ * store, the file does not exist as far as the application is concerned.
+ */
+export declare const fileStatus: import("drizzle-orm/pg-core").PgEnum<["pending", "ready", "failed"]>;
+/**
+ * A stored file.
+ *
+ * The core owns the *record* — where the bytes are, what they are, who uploaded
+ * them, whether the upload finished. It does not own the **association**: a
+ * product table references `files.id` to say what a file is *for*, because only
+ * the product knows whether it is an avatar, an import or an attachment.
+ */
+export declare const files: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "files";
+    schema: undefined;
+    columns: {
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "files";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "files";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "files";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        workspaceId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "workspace_id";
+            tableName: "files";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        storageKey: import("drizzle-orm/pg-core").PgColumn<{
+            name: "storage_key";
+            tableName: "files";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        filename: import("drizzle-orm/pg-core").PgColumn<{
+            name: "filename";
+            tableName: "files";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        contentType: import("drizzle-orm/pg-core").PgColumn<{
+            name: "content_type";
+            tableName: "files";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        sizeBytes: import("drizzle-orm/pg-core").PgColumn<{
+            name: "size_bytes";
+            tableName: "files";
+            dataType: "number";
+            columnType: "PgBigInt53";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        checksum: import("drizzle-orm/pg-core").PgColumn<{
+            name: "checksum";
+            tableName: "files";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        uploadedByUserId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "uploaded_by_user_id";
+            tableName: "files";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        status: import("drizzle-orm/pg-core").PgColumn<{
+            name: "status";
+            tableName: "files";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "failed" | "pending" | "ready";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["pending", "ready", "failed"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        confirmedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "confirmed_at";
+            tableName: "files";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        metadata: import("drizzle-orm/pg-core").PgColumn<{
+            name: "metadata";
+            tableName: "files";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: 'pg';
+}>;
+export declare const filesRelations: import("drizzle-orm").Relations<"files", {
+    workspace: import("drizzle-orm").One<"workspaces", true>;
+    uploadedBy: import("drizzle-orm").One<"users", false>;
+}>;
+export type FileRecord = typeof files.$inferSelect;
+export type NewFileRecord = typeof files.$inferInsert;
+export type FileStatus = (typeof fileStatus.enumValues)[number];
+//# sourceMappingURL=files.d.ts.map

package/dist/db/schema/files.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"files.d.ts","sourceRoot":"","sources":["../../../src/db/schema/files.ts"],"names":[],"mappings":"AAgBA;;;;;;;GAOG;AACH,eAAO,MAAM,UAAU,sEAKrB,CAAC;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyDjB,CAAC;AAEF,eAAO,MAAM,cAAc;;;EAGxB,CAAC;AAEJ,MAAM,MAAM,UAAU,GAAG,OAAO,KAAK,CAAC,YAAY,CAAC;AACnD,MAAM,MAAM,aAAa,GAAG,OAAO,KAAK,CAAC,YAAY,CAAC;AACtD,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,UAAU,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC"}

package/dist/db/schema/files.js

@@ -0,0 +1,74 @@
+import { relations } from "drizzle-orm";
+import { bigint, index, jsonb, pgEnum, pgTable, text, timestamp, uuid, } from "drizzle-orm/pg-core";
+import { primaryId, timestamps } from "./_shared.js";
+import { users } from "./users.js";
+import { workspaces } from "./workspaces.js";
+/**
+ * Upload lifecycle.
+ *
+ * `pending` exists because of direct browser uploads: the server issues a
+ * presigned URL and the client sends the bytes out-of-band, so the row has to be
+ * created *before* anything is stored. Until the upload is confirmed against the
+ * store, the file does not exist as far as the application is concerned.
+ */
+export const fileStatus = pgEnum("file_status", [
+    "pending",
+    "ready",
+    /** Confirmation found no object, or found one that failed its checks. */
+    "failed",
+]);
+/**
+ * A stored file.
+ *
+ * The core owns the *record* — where the bytes are, what they are, who uploaded
+ * them, whether the upload finished. It does not own the **association**: a
+ * product table references `files.id` to say what a file is *for*, because only
+ * the product knows whether it is an avatar, an import or an attachment.
+ */
+export const files = pgTable("files", {
+    id: primaryId(),
+    workspaceId: uuid("workspace_id")
+        .notNull()
+        .references(() => workspaces.id, { onDelete: "cascade" }),
+    /**
+     * Key in the object store, derived from this row's id and never from caller
+     * input — so a filename can contain anything without becoming a path.
+     */
+    storageKey: text("storage_key").notNull().unique(),
+    /** Original filename, for display and `Content-Disposition`. Sanitised. */
+    filename: text("filename").notNull(),
+    contentType: text("content_type"),
+    /**
+     * Size in bytes. Null while pending: a presigned `PUT` cannot enforce a
+     * size, so the real figure is only known once the object is confirmed.
+     */
+    sizeBytes: bigint("size_bytes", { mode: "number" }),
+    /** SHA-256 of the content, when the server saw the bytes. */
+    checksum: text("checksum"),
+    /** Set null on user deletion: the file outlives the account that uploaded it. */
+    uploadedByUserId: uuid("uploaded_by_user_id").references(() => users.id, {
+        onDelete: "set null",
+    }),
+    status: fileStatus("status").notNull().default("pending"),
+    /** When the upload was confirmed against the store. */
+    confirmedAt: timestamp("confirmed_at", { withTimezone: true, mode: "date" }),
+    /** Application metadata. Never a secret — this is readable wherever the row is. */
+    metadata: jsonb("metadata"),
+    ...timestamps,
+}, (table) => [
+    /** "This workspace's files, newest first" — the listing query. */
+    index("files_workspace_created_idx").on(table.workspaceId, table.createdAt.desc()),
+    /**
+     * Finds abandoned uploads for collection. A presigned URL that is never used
+     * leaves a `pending` row behind, and without this the sweep would scan every
+     * file ever stored.
+     */
+    index("files_status_created_idx").on(table.status, table.createdAt),
+    /** Content-addressed lookups, for deduplication. */
+    index("files_workspace_checksum_idx").on(table.workspaceId, table.checksum),
+]);
+export const filesRelations = relations(files, ({ one }) => ({
+    workspace: one(workspaces, { fields: [files.workspaceId], references: [workspaces.id] }),
+    uploadedBy: one(users, { fields: [files.uploadedByUserId], references: [users.id] }),
+}));
+//# sourceMappingURL=files.js.map

package/dist/db/schema/files.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"files.js","sourceRoot":"","sources":["../../../src/db/schema/files.ts"],"names":[],"mappings":"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"}