@m5kdev/backend 0.1.0 → 0.1.2

package/dist/src/modules/social/social.service.d.ts

@@ -0,0 +1,29 @@
+import type { ServerResultAsync } from "#modules/base/base.dto";
+import { BaseService } from "#modules/base/base.service";
+import type { ConnectRepository } from "#modules/connect/connect.repository";
+import type { ConnectService } from "#modules/connect/connect.service";
+import type { FileService } from "#modules/file/file.service";
+import type { SocialPostInput } from "./social.dto";
+import type { SocialPostResult, SocialProvider } from "./social.types";
+export declare class SocialService extends BaseService<{
+    connect: ConnectRepository;
+}, {
+    connect: ConnectService;
+    file: FileService;
+}> {
+    private providers;
+    constructor(repositories: {
+        connect: ConnectRepository;
+    }, services: {
+        connect: ConnectService;
+        file: FileService;
+    }, providers: SocialProvider[]);
+    getProvider(id: string): SocialProvider | null;
+    postToProvider(providerId: string, input: SocialPostInput, { user }: {
+        user: {
+            id: string;
+        };
+    }): ServerResultAsync<SocialPostResult>;
+    private ensureFreshConnection;
+}
+//# sourceMappingURL=social.service.d.ts.map

package/dist/src/modules/social/social.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"social.service.d.ts","sourceRoot":"","sources":["../../../../src/modules/social/social.service.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAChE,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AACzD,OAAO,KAAK,EAAE,iBAAiB,EAAc,MAAM,qCAAqC,CAAC;AACzF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AACvE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AACpD,OAAO,KAAK,EAAqB,gBAAgB,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAE1F,qBAAa,aAAc,SAAQ,WAAW,CAC5C;IACE,OAAO,EAAE,iBAAiB,CAAC;CAC5B,EACD;IACE,OAAO,EAAE,cAAc,CAAC;IACxB,IAAI,EAAE,WAAW,CAAC;CACnB,CACF;IACC,OAAO,CAAC,SAAS,CAAqC;gBAGpD,YAAY,EAAE;QAAE,OAAO,EAAE,iBAAiB,CAAA;KAAE,EAC5C,QAAQ,EAAE;QAAE,OAAO,EAAE,cAAc,CAAC;QAAC,IAAI,EAAE,WAAW,CAAA;KAAE,EACxD,SAAS,EAAE,cAAc,EAAE;IAM7B,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI;IAIxC,cAAc,CAClB,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,eAAe,EACtB,EAAE,IAAI,EAAE,EAAE;QAAE,IAAI,EAAE;YAAE,EAAE,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,GACjC,iBAAiB,CAAC,gBAAgB,CAAC;YAsDxB,qBAAqB;CAoBpC"}

package/dist/src/modules/social/social.service.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SocialService = void 0;
+const neverthrow_1 = require("neverthrow");
+const base_service_1 = require("#modules/base/base.service");
+class SocialService extends base_service_1.BaseService {
+    providers = new Map();
+    constructor(repositories, services, providers) {
+        super(repositories, services);
+        this.providers = new Map(providers.map((provider) => [provider.id, provider]));
+    }
+    getProvider(id) {
+        return this.providers.get(id) ?? null;
+    }
+    async postToProvider(providerId, input, { user }) {
+        return this.throwableAsync(async () => {
+            const provider = this.getProvider(providerId);
+            if (!provider) {
+                return this.error("BAD_REQUEST", `Unknown provider: ${providerId}`);
+            }
+            const connectionResult = await this.repository.connect.list({
+                userId: user.id,
+                providers: [providerId],
+            });
+            if (connectionResult.isErr()) {
+                return this.error("INTERNAL_SERVER_ERROR", "Failed to load connection", {
+                    cause: connectionResult.error,
+                });
+            }
+            const activeConnection = connectionResult.value.sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime())[0];
+            const connection = await this.ensureFreshConnection(activeConnection);
+            if (connection.isErr()) {
+                return this.error("INTERNAL_SERVER_ERROR", "Failed to refresh connection", {
+                    cause: connection.error,
+                });
+            }
+            const payload = {
+                text: input.text,
+                media: input.media,
+                visibility: input.visibility ?? "PUBLIC",
+            };
+            const accessToken = connection.value.accessToken;
+            if (!accessToken) {
+                return this.error("BAD_REQUEST", "Missing access token for connection");
+            }
+            const result = await provider.post({
+                deps: { fileService: this.service.file },
+                context: {
+                    userId: user.id,
+                    connection: connection.value,
+                    accessToken,
+                },
+                payload,
+            });
+            return (0, neverthrow_1.ok)(result);
+        });
+    }
+    async ensureFreshConnection(connection) {
+        if (!connection.expiresAt || !connection.refreshToken) {
+            return (0, neverthrow_1.ok)(connection);
+        }
+        const expiresAt = new Date(connection.expiresAt);
+        const bufferMs = 60 * 1000; // Refresh 1 minute before expiry
+        if (Date.now() < expiresAt.getTime() - bufferMs) {
+            return (0, neverthrow_1.ok)(connection);
+        }
+        const refreshed = await this.service.connect.refreshToken(connection.id);
+        if (refreshed.isErr()) {
+            return this.error("INTERNAL_SERVER_ERROR", "Failed to refresh access token", {
+                cause: refreshed.error,
+            });
+        }
+        return (0, neverthrow_1.ok)(refreshed.value);
+    }
+}
+exports.SocialService = SocialService;

package/dist/src/modules/social/social.types.d.ts

@@ -0,0 +1,36 @@
+import type { ConnectRow } from "#modules/connect/connect.repository";
+import type { FileService } from "#modules/file/file.service";
+export type SocialMediaType = "image" | "video" | "document";
+export interface SocialMediaDescriptor {
+    readonly s3Path: string;
+    readonly mediaType?: SocialMediaType;
+    readonly title?: string;
+    readonly description?: string;
+}
+export type SocialVisibility = "PUBLIC" | "CONNECTIONS";
+export interface SocialPostPayload {
+    readonly text: string;
+    readonly media?: readonly SocialMediaDescriptor[];
+    readonly visibility: SocialVisibility;
+}
+export interface SocialProviderContext {
+    readonly userId: string;
+    readonly connection: ConnectRow;
+    readonly accessToken: string;
+}
+export interface SocialProviderDeps {
+    readonly fileService: FileService;
+}
+export interface SocialPostResult {
+    readonly shareUrn?: string;
+    readonly rawResponse?: unknown;
+}
+export interface SocialProvider {
+    readonly id: string;
+    post(options: {
+        deps: SocialProviderDeps;
+        context: SocialProviderContext;
+        payload: SocialPostPayload;
+    }): Promise<SocialPostResult>;
+}
+//# sourceMappingURL=social.types.d.ts.map

package/dist/src/modules/social/social.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"social.types.d.ts","sourceRoot":"","sources":["../../../../src/modules/social/social.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AACtE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAE9D,MAAM,MAAM,eAAe,GAAG,OAAO,GAAG,OAAO,GAAG,UAAU,CAAC;AAE7D,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,SAAS,CAAC,EAAE,eAAe,CAAC;IACrC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED,MAAM,MAAM,gBAAgB,GAAG,QAAQ,GAAG,aAAa,CAAC;AAExD,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,qBAAqB,EAAE,CAAC;IAClD,QAAQ,CAAC,UAAU,EAAE,gBAAgB,CAAC;CACvC;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAChC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC;CACnC;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC;CAChC;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,OAAO,EAAE;QACZ,IAAI,EAAE,kBAAkB,CAAC;QACzB,OAAO,EAAE,qBAAqB,CAAC;QAC/B,OAAO,EAAE,iBAAiB,CAAC;KAC5B,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC;CAC/B"}

package/dist/src/modules/social/social.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/modules/tag/tag.db.d.ts

@@ -0,0 +1,347 @@
+export declare const tags: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "tags";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "id";
+            tableName: "tags";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "created_at";
+            tableName: "tags";
+            dataType: "date";
+            columnType: "SQLiteTimestamp";
+            data: Date;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "updated_at";
+            tableName: "tags";
+            dataType: "date";
+            columnType: "SQLiteTimestamp";
+            data: Date;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        deletedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "deleted_at";
+            tableName: "tags";
+            dataType: "date";
+            columnType: "SQLiteTimestamp";
+            data: Date;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        userId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "user_id";
+            tableName: "tags";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        organizationId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "organization_id";
+            tableName: "tags";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        teamId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "team_id";
+            tableName: "tags";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        name: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "name";
+            tableName: "tags";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        color: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "color";
+            tableName: "tags";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        type: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "type";
+            tableName: "tags";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        isEnabled: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "is_enabled";
+            tableName: "tags";
+            dataType: "boolean";
+            columnType: "SQLiteBoolean";
+            data: boolean;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        parentId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "parent_id";
+            tableName: "tags";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        assignableTo: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "assignable_to";
+            tableName: "tags";
+            dataType: "json";
+            columnType: "SQLiteTextJson";
+            data: string[];
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: string[];
+        }>;
+    };
+    dialect: "sqlite";
+}>;
+export declare const taggings: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "taggings";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "id";
+            tableName: "taggings";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "created_at";
+            tableName: "taggings";
+            dataType: "date";
+            columnType: "SQLiteTimestamp";
+            data: Date;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        tagId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "tag_id";
+            tableName: "taggings";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        resourceType: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "resource_type";
+            tableName: "taggings";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        resourceId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "resource_id";
+            tableName: "taggings";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+    };
+    dialect: "sqlite";
+}>;
+//# sourceMappingURL=tag.db.d.ts.map

package/dist/src/modules/tag/tag.db.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tag.db.d.ts","sourceRoot":"","sources":["../../../../src/modules/tag/tag.db.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwBf,CAAC;AAEH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAUnB,CAAC"}

package/dist/src/modules/tag/tag.db.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.taggings = exports.tags = void 0;
+const sqlite_core_1 = require("drizzle-orm/sqlite-core");
+const uuid_1 = require("uuid");
+const auth_db_1 = require("#modules/auth/auth.db");
+exports.tags = (0, sqlite_core_1.sqliteTable)("tags", {
+    id: (0, sqlite_core_1.text)("id").primaryKey().$default(uuid_1.v4),
+    createdAt: (0, sqlite_core_1.integer)("created_at", { mode: "timestamp" })
+        .notNull()
+        .$default(() => new Date()),
+    updatedAt: (0, sqlite_core_1.integer)("updated_at", { mode: "timestamp" }),
+    deletedAt: (0, sqlite_core_1.integer)("deleted_at", { mode: "timestamp" }),
+    userId: (0, sqlite_core_1.text)("user_id")
+        .notNull()
+        .references(() => auth_db_1.users.id, { onDelete: "cascade" }),
+    organizationId: (0, sqlite_core_1.text)("organization_id").references(() => auth_db_1.organizations.id, {
+        onDelete: "cascade",
+    }),
+    teamId: (0, sqlite_core_1.text)("team_id").references(() => auth_db_1.teams.id, { onDelete: "cascade" }),
+    name: (0, sqlite_core_1.text)("name").notNull(),
+    color: (0, sqlite_core_1.text)("color"),
+    type: (0, sqlite_core_1.text)("type"),
+    isEnabled: (0, sqlite_core_1.integer)("is_enabled", { mode: "boolean" }).notNull().default(true),
+    parentId: (0, sqlite_core_1.text)("parent_id").references(() => exports.tags.id, { onDelete: "set null" }),
+    assignableTo: (0, sqlite_core_1.text)("assignable_to", {
+        mode: "json",
+    })
+        .notNull()
+        .$type(),
+});
+exports.taggings = (0, sqlite_core_1.sqliteTable)("taggings", {
+    id: (0, sqlite_core_1.text)("id").primaryKey().$default(uuid_1.v4),
+    createdAt: (0, sqlite_core_1.integer)("created_at", { mode: "timestamp" })
+        .notNull()
+        .$default(() => new Date()),
+    tagId: (0, sqlite_core_1.text)("tag_id")
+        .notNull()
+        .references(() => exports.tags.id),
+    resourceType: (0, sqlite_core_1.text)("resource_type").notNull(), // e.g., "post", "image"
+    resourceId: (0, sqlite_core_1.text)("resource_id").notNull(), // id in the resource table
+});