@m5kdev/backend 0.1.0 → 0.1.2

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

@@ -0,0 +1 @@
+{"version":3,"file":"tag.dto.d.ts","sourceRoot":"","sources":["../../../../src/modules/tag/tag.dto.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AACzC,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAG7B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEjD,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAwB,CAAC;AACnD,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA4B,CAAC;AAE3D,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAAuB,CAAC;AACrD,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAA2B,CAAC;AAE7D,MAAM,MAAM,qBAAqB,GAAG,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,EAAE,WAAW,CAAC,CAAC;AAC1F,MAAM,MAAM,yBAAyB,GAAG,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,EAAE,WAAW,CAAC,CAAC;AAClG,MAAM,MAAM,0BAA0B,GAAG,MAAM,CAC7C,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,EAAE,EACtC,WAAW,CACZ,CAAC"}

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.d.ts

@@ -0,0 +1,384 @@
+import type { TaggingSchema, TagLinkSchema, TagListInputSchema, TagListSchema, TagSchema } from "@m5kdev/commons/modules/tag/tag.schema";
+import type { LibSQLDatabase } from "drizzle-orm/libsql";
+import type { ServerResultAsync } from "#modules/base/base.dto";
+import { BaseTableRepository } from "#modules/base/base.repository";
+import type { TaggingSelectOutputResult, TagSelectOutputResult } from "#modules/tag/tag.dto";
+declare const schema: {
+    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";
+    }>;
+    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";
+    }>;
+};
+type Schema = typeof schema;
+type Orm = LibSQLDatabase<Schema>;
+export declare class TagRepository extends BaseTableRepository<Orm, Schema, Record<string, never>, Schema["tags"]> {
+    link({ userId, ...data }: TagLinkSchema & {
+        userId: string;
+    }, tx?: Orm): Promise<TaggingSelectOutputResult>;
+    linkBulk(data: TagLinkSchema[], tx?: Orm): ServerResultAsync<TagSchema[]>;
+    set(data: TagLinkSchema[], tx?: Orm): ServerResultAsync<TagSchema[]>;
+    unlink({ userId, ...data }: TagLinkSchema & {
+        userId: string;
+    }, tx?: Orm): Promise<TagSelectOutputResult>;
+    findTagsForResources(data: {
+        resourceType: string;
+        resourceIds: readonly string[];
+    }, tx?: Orm): ServerResultAsync<Record<string, TagSchema[]>>;
+    attachTagsToResources<TRow extends {
+        id: string;
+    }>(resourceType: string, rows: readonly TRow[], tx?: Orm): ServerResultAsync<Array<TRow & {
+        tags: TagSchema[];
+    }>>;
+    listTaggings(input: {
+        resourceType: string;
+        resourceIds?: readonly string[];
+    }, tx?: Orm): ServerResultAsync<TaggingSchema[]>;
+    list(input: (TagListInputSchema & TagListSchema) | undefined, tx?: Orm): ServerResultAsync<{
+        rows: TagSchema[];
+        total: number;
+    }>;
+}
+export {};
+//# sourceMappingURL=tag.repository.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tag.repository.d.ts","sourceRoot":"","sources":["../../../../src/modules/tag/tag.repository.ts"],"names":[],"mappings":"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"}

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.d.ts

@@ -0,0 +1,36 @@
+import type { TagCreateSchema, TagLinkSchema, TagListInputSchema, TagListOutputSchema, TagListSchema, TagSchema, TagUpdateSchema } from "@m5kdev/commons/modules/tag/tag.schema";
+import type { User } from "#modules/auth/auth.lib";
+import type { ServerResultAsync } from "#modules/base/base.dto";
+import { BaseService } from "#modules/base/base.service";
+import type { TaggingSelectOutputResult, TagSelectOutputResult } from "#modules/tag/tag.dto";
+import type { TagRepository } from "#modules/tag/tag.repository";
+export declare class TagService extends BaseService<{
+    tag: TagRepository;
+}, Record<string, never>> {
+    list(input: TagListInputSchema & TagListSchema): ServerResultAsync<TagListOutputSchema>;
+    listTaggings(input: {
+        resourceType: string;
+        resourceIds?: readonly string[];
+    }): Promise<import("#modules/base/base.dto").ServerResult<{
+        id: string;
+        createdAt: Date;
+        tagId: string;
+        resourceType: string;
+        resourceId: string;
+    }[]>>;
+    create(data: TagCreateSchema, { user }: {
+        user: User;
+    }): Promise<TagSelectOutputResult>;
+    update(data: TagUpdateSchema, { user }: {
+        user: User;
+    }): Promise<TagSelectOutputResult>;
+    link(data: TagLinkSchema, { user }: {
+        user: User;
+    }): Promise<TaggingSelectOutputResult>;
+    linkBulk(data: TagLinkSchema[]): ServerResultAsync<TagSchema[]>;
+    set(data: TagLinkSchema[]): ServerResultAsync<TagSchema[]>;
+    unlink(data: TagLinkSchema, { user }: {
+        user: User;
+    }): Promise<TagSelectOutputResult>;
+}
+//# sourceMappingURL=tag.service.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tag.service.d.ts","sourceRoot":"","sources":["../../../../src/modules/tag/tag.service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,aAAa,EACb,kBAAkB,EAClB,mBAAmB,EACnB,aAAa,EACb,SAAS,EACT,eAAe,EAChB,MAAM,wCAAwC,CAAC;AAChD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,wBAAwB,CAAC;AACnD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAChE,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AACzD,OAAO,KAAK,EAAE,yBAAyB,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAC7F,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAEjE,qBAAa,UAAW,SAAQ,WAAW,CAAC;IAAE,GAAG,EAAE,aAAa,CAAA;CAAE,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAClF,IAAI,CAAC,KAAK,EAAE,kBAAkB,GAAG,aAAa,GAAG,iBAAiB,CAAC,mBAAmB,CAAC;IAIvF,YAAY,CAAC,KAAK,EAAE;QAAE,YAAY,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;KAAE;;;;;;;IAI7E,MAAM,CAAC,IAAI,EAAE,eAAe,EAAE,EAAE,IAAI,EAAE,EAAE;QAAE,IAAI,EAAE,IAAI,CAAA;KAAE,GAAG,OAAO,CAAC,qBAAqB,CAAC;IAIvF,MAAM,CAAC,IAAI,EAAE,eAAe,EAAE,EAAE,IAAI,EAAE,EAAE;QAAE,IAAI,EAAE,IAAI,CAAA;KAAE,GAAG,OAAO,CAAC,qBAAqB,CAAC;IAIvF,IAAI,CAAC,IAAI,EAAE,aAAa,EAAE,EAAE,IAAI,EAAE,EAAE;QAAE,IAAI,EAAE,IAAI,CAAA;KAAE,GAAG,OAAO,CAAC,yBAAyB,CAAC;IAIvF,QAAQ,CAAC,IAAI,EAAE,aAAa,EAAE,GAAG,iBAAiB,CAAC,SAAS,EAAE,CAAC;IAI/D,GAAG,CAAC,IAAI,EAAE,aAAa,EAAE,GAAG,iBAAiB,CAAC,SAAS,EAAE,CAAC;IAI1D,MAAM,CAAC,IAAI,EAAE,aAAa,EAAE,EAAE,IAAI,EAAE,EAAE;QAAE,IAAI,EAAE,IAAI,CAAA;KAAE,GAAG,OAAO,CAAC,qBAAqB,CAAC;CAG5F"}

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;