@m5kdev/backend 0.1.1 → 0.1.3

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.js

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

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
+});

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.taggingsSelectOutput = exports.tagsSelectOutput = exports.taggingsSelectDTO = exports.tagsSelectDTO = void 0;
+const base_dto_1 = require("#modules/base/base.dto");
+const tag_db_1 = require("#modules/tag/tag.db");
+exports.tagsSelectDTO = (0, base_dto_1.createSelectDTO)(tag_db_1.tags);
+exports.taggingsSelectDTO = (0, base_dto_1.createSelectDTO)(tag_db_1.taggings);
+exports.tagsSelectOutput = exports.tagsSelectDTO.schema;
+exports.taggingsSelectOutput = exports.taggingsSelectDTO.schema;

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

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TagRepository = void 0;
+const tslib_1 = require("tslib");
+const drizzle_orm_1 = require("drizzle-orm");
+const neverthrow_1 = require("neverthrow");
+const base_repository_1 = require("#modules/base/base.repository");
+const tag = tslib_1.__importStar(require("#modules/tag/tag.db"));
+const schema = { ...tag };
+class TagRepository extends base_repository_1.BaseTableRepository {
+    async link({ userId, ...data }, tx) {
+        return this.throwableAsync(async () => {
+            const db = tx ?? this.orm;
+            const [foundTag] = await db
+                .select({ id: this.schema.tags.id })
+                .from(this.schema.tags)
+                .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(this.schema.tags.id, data.tagId), (0, drizzle_orm_1.eq)(this.schema.tags.userId, userId)))
+                .limit(1);
+            if (!foundTag)
+                return this.error("FORBIDDEN");
+            const [tagging] = await db
+                .insert(this.schema.taggings)
+                .values({ ...data, tagId: foundTag.id })
+                .returning();
+            if (!tagging)
+                return this.error("NOT_FOUND");
+            return (0, neverthrow_1.ok)(tagging);
+        });
+    }
+    async linkBulk(data, tx) {
+        return this.throwableAsync(async () => {
+            const db = tx ?? this.orm;
+            await db.insert(this.schema.taggings).values(data);
+            const tags = await db
+                .select()
+                .from(this.schema.tags)
+                .where((0, drizzle_orm_1.inArray)(this.schema.tags.id, data.map((tag) => tag.tagId)));
+            return (0, neverthrow_1.ok)(tags);
+        });
+    }
+    async set(data, tx) {
+        return this.throwableAsync(async () => {
+            const db = tx ?? this.orm;
+            const result = await db.transaction(async (trx) => {
+                // FIXME: We are assuming that all resourceIds are the same, this is not a good assumption.
+                await trx
+                    .delete(this.schema.taggings)
+                    .where((0, drizzle_orm_1.eq)(this.schema.taggings.resourceId, data[0].resourceId));
+                await db.insert(this.schema.taggings).values(data);
+                const tags = await db
+                    .select()
+                    .from(this.schema.tags)
+                    .where((0, drizzle_orm_1.inArray)(this.schema.tags.id, data.map((tag) => tag.tagId)));
+                return tags;
+            });
+            return (0, neverthrow_1.ok)(result);
+        });
+    }
+    async unlink({ userId, ...data }, tx) {
+        return this.throwableAsync(async () => {
+            const db = tx ?? this.orm;
+            const [foundTag] = await db
+                .select()
+                .from(this.schema.tags)
+                .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(this.schema.tags.id, data.tagId), (0, drizzle_orm_1.eq)(this.schema.tags.userId, userId)))
+                .limit(1);
+            if (!foundTag)
+                return this.error("FORBIDDEN");
+            await db
+                .delete(this.schema.taggings)
+                .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(this.schema.taggings.tagId, data.tagId), (0, drizzle_orm_1.eq)(this.schema.taggings.resourceId, data.resourceId), (0, drizzle_orm_1.eq)(this.schema.taggings.resourceType, data.resourceType)));
+            return (0, neverthrow_1.ok)(foundTag);
+        });
+    }
+    async findTagsForResources(data, tx) {
+        return this.throwableAsync(async () => {
+            const db = tx ?? this.orm;
+            if (data.resourceIds.length === 0)
+                return (0, neverthrow_1.ok)({});
+            const taggings = await db
+                .select({
+                resourceId: this.schema.taggings.resourceId,
+                tagId: this.schema.taggings.tagId,
+            })
+                .from(this.schema.taggings)
+                .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(this.schema.taggings.resourceType, data.resourceType), (0, drizzle_orm_1.inArray)(this.schema.taggings.resourceId, data.resourceIds)));
+            if (taggings.length === 0)
+                return (0, neverthrow_1.ok)({});
+            const tagIds = Array.from(new Set(taggings.map((tagging) => tagging.tagId)));
+            const tags = await db
+                .select()
+                .from(this.schema.tags)
+                .where((0, drizzle_orm_1.inArray)(this.schema.tags.id, tagIds));
+            const tagById = tags.reduce((acc, tagRow) => {
+                acc[tagRow.id] = tagRow;
+                return acc;
+            }, {});
+            const grouped = taggings.reduce((acc, tagging) => {
+                const tagRow = tagById[tagging.tagId];
+                if (!tagRow)
+                    return acc;
+                const existing = acc[tagging.resourceId] ?? [];
+                acc[tagging.resourceId] = [...existing, tagRow];
+                return acc;
+            }, {});
+            return (0, neverthrow_1.ok)(grouped);
+        });
+    }
+    async attachTagsToResources(resourceType, rows, tx) {
+        return this.throwableAsync(async () => {
+            if (rows.length === 0)
+                return (0, neverthrow_1.ok)([]);
+            const tagsResult = await this.findTagsForResources({ resourceType, resourceIds: rows.map((row) => row.id) }, tx);
+            if (tagsResult.isErr())
+                return (0, neverthrow_1.err)(tagsResult.error);
+            const tagsByResource = tagsResult.value;
+            const withTags = rows.map((row) => ({
+                ...row,
+                tags: tagsByResource[row.id] ?? [],
+            }));
+            return (0, neverthrow_1.ok)(withTags);
+        });
+    }
+    async listTaggings(input, tx) {
+        return this.throwableAsync(async () => {
+            const db = tx ?? this.orm;
+            const filters = [(0, drizzle_orm_1.eq)(this.schema.taggings.resourceType, input.resourceType)];
+            if (input.resourceIds?.length) {
+                filters.push((0, drizzle_orm_1.inArray)(this.schema.taggings.resourceId, input.resourceIds));
+            }
+            const rows = await db
+                .select()
+                .from(this.schema.taggings)
+                .where((0, drizzle_orm_1.and)(...filters));
+            return (0, neverthrow_1.ok)(rows);
+        });
+    }
+    async list(input, tx) {
+        return this.throwableAsync(async () => {
+            const db = tx ?? this.orm;
+            const conditions = this.getConditionBuilder(this.table);
+            conditions.applyFilters(input);
+            if (input?.assignableTo) {
+                conditions.push(this.helpers.arrayContains(this.table.assignableTo, [input.assignableTo]));
+            }
+            const whereClause = conditions.join();
+            const rowsQuery = this.withSortingAndPagination(db.select().from(this.table).where(whereClause), input || {});
+            const countQuery = db.select({ count: (0, drizzle_orm_1.count)() }).from(this.table).where(whereClause);
+            const [rows, [totalResult]] = await Promise.all([rowsQuery, countQuery]);
+            return (0, neverthrow_1.ok)({ rows, total: totalResult?.count ?? 0 });
+        });
+    }
+}
+exports.TagRepository = TagRepository;

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TagService = void 0;
+const base_service_1 = require("#modules/base/base.service");
+class TagService extends base_service_1.BaseService {
+    async list(input) {
+        return this.repository.tag.list(input);
+    }
+    async listTaggings(input) {
+        return this.repository.tag.listTaggings(input);
+    }
+    async create(data, { user }) {
+        return this.repository.tag.create({ ...data, userId: user.id });
+    }
+    async update(data, { user }) {
+        return this.repository.tag.update({ ...data, userId: user.id });
+    }
+    async link(data, { user }) {
+        return this.repository.tag.link({ ...data, userId: user.id });
+    }
+    async linkBulk(data) {
+        return this.repository.tag.linkBulk(data);
+    }
+    async set(data) {
+        return this.repository.tag.set(data);
+    }
+    async unlink(data, { user }) {
+        return this.repository.tag.unlink({ ...data, userId: user.id });
+    }
+}
+exports.TagService = TagService;

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

@@ -4,9 +4,9 @@ export declare function createTagTRPC(tagService: TagService): import("@trpc/ser
         session: {
             id: string;
             userId: string;
-            expiresAt: Date;
-            createdAt: Date;
             updatedAt: Date;
+            createdAt: Date;
+            expiresAt: Date;
             token: string;
             ipAddress: string | null;
             userAgent: string | null;
@@ -18,13 +18,12 @@ export declare function createTagTRPC(tagService: TagService): import("@trpc/ser
         };
         user: {
             name: string;
-            image: string | null;
             id: string;
-            createdAt: Date;
             updatedAt: Date;
             email: string;
-            metadata: Record<string, unknown>;
             emailVerified: boolean;
+            image: string | null;
+            createdAt: Date;
             role: string | null;
             banned: boolean | null;
             banReason: string | null;
@@ -34,6 +33,7 @@ export declare function createTagTRPC(tagService: TagService): import("@trpc/ser
             paymentPlanTier: string | null;
             paymentPlanExpiresAt: Date | null;
             preferences: string | null;
+            metadata: Record<string, unknown>;
             onboarding: number | null;
             flags: string | null;
         };

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTagTRPC = createTagTRPC;
+const tag_schema_1 = require("@m5kdev/commons/modules/tag/tag.schema");
+const tag_dto_1 = require("#modules/tag/tag.dto");
+const _trpc_1 = require("#trpc");
+function createTagTRPC(tagService) {
+    const tagListInput = tag_schema_1.tagListInputSchema.extend({
+        assignableTo: tag_schema_1.tagListSchema.shape.assignableTo,
+    });
+    return (0, _trpc_1.router)({
+        list: _trpc_1.procedure
+            .input(tagListInput)
+            .output(tag_schema_1.tagListOutputSchema)
+            .query(async ({ input }) => (0, _trpc_1.handleTRPCResult)(await tagService.list(input))),
+        listTaggings: _trpc_1.procedure
+            .input(tag_schema_1.taggingSchema
+            .pick({ resourceType: true })
+            .extend({ resourceIds: tag_schema_1.tagListInputSchema.shape.filters.optional() }))
+            .output(tag_dto_1.taggingsSelectOutput.array())
+            .query(async ({ input }) => (0, _trpc_1.handleTRPCResult)(await tagService.listTaggings(input))),
+        create: _trpc_1.procedure
+            .input(tag_schema_1.tagCreateSchema)
+            .output(tag_dto_1.tagsSelectOutput)
+            .mutation(async ({ ctx, input }) => {
+            return (0, _trpc_1.handleTRPCResult)(await tagService.create(input, ctx));
+        }),
+        update: _trpc_1.procedure
+            .input(tag_schema_1.tagUpdateSchema)
+            .output(tag_dto_1.tagsSelectOutput)
+            .mutation(async ({ ctx, input }) => {
+            return (0, _trpc_1.handleTRPCResult)(await tagService.update(input, ctx));
+        }),
+        link: _trpc_1.procedure
+            .input(tag_schema_1.tagLinkSchema)
+            .output(tag_dto_1.taggingsSelectOutput)
+            .mutation(async ({ ctx, input }) => {
+            return (0, _trpc_1.handleTRPCResult)(await tagService.link(input, ctx));
+        }),
+        unlink: _trpc_1.procedure
+            .input(tag_schema_1.tagLinkSchema)
+            .output(tag_dto_1.tagsSelectOutput)
+            .mutation(async ({ ctx, input }) => {
+            return (0, _trpc_1.handleTRPCResult)(await tagService.unlink(input, ctx));
+        }),
+    });
+}

package/dist/src/modules/utils/applyPagination.js

@@ -0,0 +1,16 @@
+"use strict";
+/**
+ * Applies pagination (limit and offset) to a drizzle query builder.
+ * Returns the query builder with pagination applied, or the original query if no limit is specified.
+ * Page is 1-based and only applied if limit is also provided.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyPagination = void 0;
+const applyPagination = (query, limit, page) => {
+    if (limit)
+        query.limit(limit);
+    if (page && page > 1 && limit)
+        query.offset((page - 1) * limit);
+    return query;
+};
+exports.applyPagination = applyPagination;

package/dist/src/modules/utils/applySorting.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applySorting = void 0;
+const drizzle_orm_1 = require("drizzle-orm");
+/**
+ * Applies sorting to a drizzle query builder.
+ * Returns the query builder with sorting applied.
+ * If no sort or order is specified, defaults to createdAt descending.
+ * If createdAt column doesn't exist, returns the query unchanged.
+ */
+const applySorting = (query, table, sort, order) => {
+    const column = sort ? table[sort] : table.createdAt || table.id;
+    if (!column)
+        throw new Error(`Column ${sort} not found in table ${table.name}`);
+    query.orderBy(order === "asc" ? (0, drizzle_orm_1.asc)(column) : (0, drizzle_orm_1.desc)(column));
+    return query;
+};
+exports.applySorting = applySorting;

package/dist/src/modules/utils/getConditionsFromFilters.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConditionsFromFilters = void 0;
+const drizzle_orm_1 = require("drizzle-orm");
+const luxon_1 = require("luxon");
+// Helper: Create UTC date boundaries from ISO string
+const getUTCDateBoundaries = (isoString) => {
+    const dateTime = luxon_1.DateTime.fromISO(isoString, { zone: "utc" });
+    return {
+        start: dateTime.startOf("day").toJSDate(),
+        end: dateTime.endOf("day").toJSDate(),
+    };
+};
+const getConditionsFromFilters = (conditions, filters, table) => {
+    if (!filters || filters.length === 0) {
+        return conditions;
+    }
+    // Process each filter (maximum one filter per column)
+    for (const filter of filters) {
+        const { columnId, type, method, value, valueTo } = filter;
+        // Get the column from the table using columnId
+        const column = table[columnId];
+        if (!column) {
+            continue; // Skip if column doesn't exist
+        }
+        // Handle isEmpty/isNotEmpty methods (work across types, ignore value)
+        if (method === "isEmpty" || method === "isNotEmpty") {
+            switch (type) {
+                case "string":
+                case "enum":
+                    // isEmpty: IS NULL OR = ''
+                    // isNotEmpty: IS NOT NULL AND != ''
+                    if (method === "isEmpty") {
+                        conditions.push((0, drizzle_orm_1.or)((0, drizzle_orm_1.isNull)(column), (0, drizzle_orm_1.eq)(column, "")));
+                    }
+                    else {
+                        conditions.push((0, drizzle_orm_1.and)((0, drizzle_orm_1.isNotNull)(column), (0, drizzle_orm_1.ne)(column, "")));
+                    }
+                    continue;
+                case "number":
+                    // isEmpty: IS NULL OR = 0
+                    // isNotEmpty: IS NOT NULL AND != 0
+                    if (method === "isEmpty") {
+                        conditions.push((0, drizzle_orm_1.or)((0, drizzle_orm_1.isNull)(column), (0, drizzle_orm_1.eq)(column, 0)));
+                    }
+                    else {
+                        conditions.push((0, drizzle_orm_1.and)((0, drizzle_orm_1.isNotNull)(column), (0, drizzle_orm_1.ne)(column, 0)));
+                    }
+                    continue;
+                case "boolean":
+                    // Should not happen per plan, but handle gracefully
+                    continue;
+                default:
+                    continue;
+            }
+        }
+        // Apply filter based on type and method
+        switch (type) {
+            case "string":
+                switch (method) {
+                    case "contains":
+                        if (typeof value === "string") {
+                            conditions.push((0, drizzle_orm_1.like)(column, `%${value}%`));
+                        }
+                        break;
+                    case "equals":
+                        if (typeof value === "string") {
+                            conditions.push((0, drizzle_orm_1.eq)(column, value));
+                        }
+                        break;
+                    case "starts_with":
+                        if (typeof value === "string") {
+                            conditions.push((0, drizzle_orm_1.like)(column, `${value}%`));
+                        }
+                        break;
+                    case "ends_with":
+                        if (typeof value === "string") {
+                            conditions.push((0, drizzle_orm_1.like)(column, `%${value}`));
+                        }
+                        break;
+                    case "is_null":
+                        conditions.push((0, drizzle_orm_1.isNull)(column));
+                        break;
+                    case "is_not_null":
+                        conditions.push((0, drizzle_orm_1.isNotNull)(column));
+                        break;
+                }
+                break;
+            case "number":
+                switch (method) {
+                    case "equals":
+                        if (typeof value === "number") {
+                            conditions.push((0, drizzle_orm_1.eq)(column, value));
+                        }
+                        break;
+                    case "greater_than":
+                        if (typeof value === "number") {
+                            conditions.push((0, drizzle_orm_1.gte)(column, value));
+                        }
+                        break;
+                    case "less_than":
+                        if (typeof value === "number") {
+                            conditions.push((0, drizzle_orm_1.lte)(column, value));
+                        }
+                        break;
+                    case "is_null":
+                        conditions.push((0, drizzle_orm_1.isNull)(column));
+                        break;
+                    case "is_not_null":
+                        conditions.push((0, drizzle_orm_1.isNotNull)(column));
+                        break;
+                }
+                break;
+            case "date":
+                if (typeof value !== "string")
+                    break;
+                switch (method) {
+                    case "on": {
+                        const { start, end } = getUTCDateBoundaries(value);
+                        conditions.push((0, drizzle_orm_1.and)((0, drizzle_orm_1.gte)(column, start), (0, drizzle_orm_1.lte)(column, end)));
+                        break;
+                    }
+                    case "between":
+                        if (valueTo) {
+                            const { start } = getUTCDateBoundaries(value);
+                            const { end } = getUTCDateBoundaries(valueTo);
+                            conditions.push((0, drizzle_orm_1.between)(column, start, end));
+                        }
+                        break;
+                    case "before": {
+                        const { end } = getUTCDateBoundaries(value);
+                        conditions.push((0, drizzle_orm_1.lte)(column, end));
+                        break;
+                    }
+                    case "after": {
+                        const { start } = getUTCDateBoundaries(value);
+                        conditions.push((0, drizzle_orm_1.gte)(column, start));
+                        break;
+                    }
+                    case "intersect": {
+                        // Interval overlap: [columnId, endColumnId] intersects with [value, valueTo]
+                        // Logic: columnId <= valueTo AND (endColumnId IS NULL OR endColumnId >= value)
+                        if (!valueTo || !filter.endColumnId)
+                            break;
+                        const endColumn = table[filter.endColumnId];
+                        if (!endColumn)
+                            break;
+                        const { start } = getUTCDateBoundaries(value);
+                        const { end } = getUTCDateBoundaries(valueTo);
+                        conditions.push((0, drizzle_orm_1.and)((0, drizzle_orm_1.lte)(column, end), (0, drizzle_orm_1.or)((0, drizzle_orm_1.isNull)(endColumn), (0, drizzle_orm_1.gte)(endColumn, start))));
+                        break;
+                    }
+                    case "is_null":
+                        conditions.push((0, drizzle_orm_1.isNull)(column));
+                        break;
+                    case "is_not_null":
+                        conditions.push((0, drizzle_orm_1.isNotNull)(column));
+                        break;
+                }
+                break;
+            case "boolean":
+                switch (method) {
+                    case "equals":
+                        if (typeof value === "boolean") {
+                            conditions.push((0, drizzle_orm_1.eq)(column, value));
+                        }
+                        break;
+                    case "is_null":
+                        conditions.push((0, drizzle_orm_1.isNull)(column));
+                        break;
+                    case "is_not_null":
+                        conditions.push((0, drizzle_orm_1.isNotNull)(column));
+                        break;
+                }
+                break;
+            case "enum":
+                switch (method) {
+                    case "oneOf":
+                        if (Array.isArray(value) && value.length > 0) {
+                            conditions.push((0, drizzle_orm_1.inArray)(column, value));
+                        }
+                        break;
+                    case "equals":
+                        if (typeof value === "string") {
+                            conditions.push((0, drizzle_orm_1.eq)(column, value));
+                        }
+                        break;
+                    case "is_null":
+                        conditions.push((0, drizzle_orm_1.isNull)(column));
+                        break;
+                    case "is_not_null":
+                        conditions.push((0, drizzle_orm_1.isNotNull)(column));
+                        break;
+                }
+                break;
+        }
+    }
+    return conditions;
+};
+exports.getConditionsFromFilters = getConditionsFromFilters;