@m5kdev/backend 0.1.0 → 0.1.2

package/dist/src/modules/recurrence/recurrence.repository.d.ts

@@ -0,0 +1,585 @@
+import type { InferInsertModel, InferSelectModel } from "drizzle-orm";
+import type { LibSQLDatabase } from "drizzle-orm/libsql";
+import type { ServerResultAsync } from "#modules/base/base.dto";
+import { BaseTableRepository } from "#modules/base/base.repository";
+declare const schema: {
+    recurrence: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+        name: "recurrence";
+        schema: undefined;
+        columns: {
+            id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "id";
+                tableName: "recurrence";
+                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;
+            }>;
+            userId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "user_id";
+                tableName: "recurrence";
+                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;
+            }>;
+            organizationId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "organization_id";
+                tableName: "recurrence";
+                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: "recurrence";
+                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: "recurrence";
+                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;
+            }>;
+            kind: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "kind";
+                tableName: "recurrence";
+                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;
+            }>;
+            enabled: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "enabled";
+                tableName: "recurrence";
+                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;
+            }, {}, {}>;
+            createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "created_at";
+                tableName: "recurrence";
+                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: "recurrence";
+                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;
+            }, {}, {}>;
+            metadata: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "metadata";
+                tableName: "recurrence";
+                dataType: "json";
+                columnType: "SQLiteTextJson";
+                data: Record<string, any>;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                $type: Record<string, any>;
+            }>;
+        };
+        dialect: "sqlite";
+    }>;
+    recurrenceRules: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+        name: "recurrence_rules";
+        schema: undefined;
+        columns: {
+            id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "id";
+                tableName: "recurrence_rules";
+                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: "recurrence_rules";
+                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: "recurrence_rules";
+                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;
+            }, {}, {}>;
+            recurrenceId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "recurrence_id";
+                tableName: "recurrence_rules";
+                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;
+            }>;
+            freq: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "freq";
+                tableName: "recurrence_rules";
+                dataType: "number";
+                columnType: "SQLiteInteger";
+                data: number;
+                driverParam: number;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            dtstart: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "dtstart";
+                tableName: "recurrence_rules";
+                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;
+            }, {}, {}>;
+            interval: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "interval";
+                tableName: "recurrence_rules";
+                dataType: "number";
+                columnType: "SQLiteInteger";
+                data: number;
+                driverParam: number;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            wkst: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "wkst";
+                tableName: "recurrence_rules";
+                dataType: "number";
+                columnType: "SQLiteInteger";
+                data: number;
+                driverParam: number;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            count: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "count";
+                tableName: "recurrence_rules";
+                dataType: "number";
+                columnType: "SQLiteInteger";
+                data: number;
+                driverParam: number;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            until: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "until";
+                tableName: "recurrence_rules";
+                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;
+            }, {}, {}>;
+            tzid: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "tzid";
+                tableName: "recurrence_rules";
+                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;
+            }>;
+            bysetpos: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "bysetpos";
+                tableName: "recurrence_rules";
+                dataType: "json";
+                columnType: "SQLiteTextJson";
+                data: number | number[];
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                $type: number | number[];
+            }>;
+            bymonth: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "bymonth";
+                tableName: "recurrence_rules";
+                dataType: "json";
+                columnType: "SQLiteTextJson";
+                data: number | number[];
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                $type: number | number[];
+            }>;
+            bymonthday: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "bymonthday";
+                tableName: "recurrence_rules";
+                dataType: "json";
+                columnType: "SQLiteTextJson";
+                data: number | number[];
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                $type: number | number[];
+            }>;
+            byyearday: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "byyearday";
+                tableName: "recurrence_rules";
+                dataType: "json";
+                columnType: "SQLiteTextJson";
+                data: number | number[];
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                $type: number | number[];
+            }>;
+            byweekno: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "byweekno";
+                tableName: "recurrence_rules";
+                dataType: "json";
+                columnType: "SQLiteTextJson";
+                data: number | number[];
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                $type: number | number[];
+            }>;
+            byweekday: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "byweekday";
+                tableName: "recurrence_rules";
+                dataType: "json";
+                columnType: "SQLiteTextJson";
+                data: number | number[];
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                $type: number | number[];
+            }>;
+            byhour: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "byhour";
+                tableName: "recurrence_rules";
+                dataType: "json";
+                columnType: "SQLiteTextJson";
+                data: number | number[];
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                $type: number | number[];
+            }>;
+            byminute: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "byminute";
+                tableName: "recurrence_rules";
+                dataType: "json";
+                columnType: "SQLiteTextJson";
+                data: number | number[];
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                $type: number | number[];
+            }>;
+            bysecond: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+                name: "bysecond";
+                tableName: "recurrence_rules";
+                dataType: "json";
+                columnType: "SQLiteTextJson";
+                data: number | number[];
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                $type: number | number[];
+            }>;
+        };
+        dialect: "sqlite";
+    }>;
+};
+type Schema = typeof schema;
+type Orm = LibSQLDatabase<Schema>;
+type RecurrenceInsert = InferInsertModel<Schema["recurrence"]>;
+type RecurrenceRulesInsert = InferInsertModel<Schema["recurrenceRules"]>;
+/** Rule input for create: rule fields without id, recurrenceId, createdAt, updatedAt */
+export type CreateRecurrenceRuleInput = Omit<RecurrenceRulesInsert, "id" | "recurrenceId" | "createdAt" | "updatedAt">;
+export interface CreateWithRulesResult {
+    recurrence: InferSelectModel<Schema["recurrence"]>;
+    rules: InferSelectModel<Schema["recurrenceRules"]>[];
+}
+export declare class RecurrenceRepository extends BaseTableRepository<Orm, Schema, Record<string, never>, Schema["recurrence"]> {
+    createWithRules(recurrenceData: RecurrenceInsert, rulesData: CreateRecurrenceRuleInput[], tx?: Orm): ServerResultAsync<CreateWithRulesResult>;
+}
+export declare class RecurrenceRulesRepository extends BaseTableRepository<Orm, Schema, Record<string, never>, Schema["recurrenceRules"]> {
+}
+export {};
+//# sourceMappingURL=recurrence.repository.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"recurrence.repository.d.ts","sourceRoot":"","sources":["../../../../src/modules/recurrence/recurrence.repository.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACtE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEzD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAChE,OAAO,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AAGpE,QAAA,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAoB,CAAC;AACjC,KAAK,MAAM,GAAG,OAAO,MAAM,CAAC;AAC5B,KAAK,GAAG,GAAG,cAAc,CAAC,MAAM,CAAC,CAAC;AAClC,KAAK,gBAAgB,GAAG,gBAAgB,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC;AAC/D,KAAK,qBAAqB,GAAG,gBAAgB,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAC,CAAC;AAEzE,wFAAwF;AACxF,MAAM,MAAM,yBAAyB,GAAG,IAAI,CAC1C,qBAAqB,EACrB,IAAI,GAAG,cAAc,GAAG,WAAW,GAAG,WAAW,CAClD,CAAC;AAEF,MAAM,WAAW,qBAAqB;IACpC,UAAU,EAAE,gBAAgB,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC;IACnD,KAAK,EAAE,gBAAgB,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAC,EAAE,CAAC;CACtD;AAED,qBAAa,oBAAqB,SAAQ,mBAAmB,CAC3D,GAAG,EACH,MAAM,EACN,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,EACrB,MAAM,CAAC,YAAY,CAAC,CACrB;IACO,eAAe,CACnB,cAAc,EAAE,gBAAgB,EAChC,SAAS,EAAE,yBAAyB,EAAE,EACtC,EAAE,CAAC,EAAE,GAAG,GACP,iBAAiB,CAAC,qBAAqB,CAAC;CA4B5C;AAED,qBAAa,yBAA0B,SAAQ,mBAAmB,CAChE,GAAG,EACH,MAAM,EACN,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,EACrB,MAAM,CAAC,iBAAiB,CAAC,CAC1B;CAAG"}

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecurrenceRulesRepository = exports.RecurrenceRepository = void 0;
+const tslib_1 = require("tslib");
+const neverthrow_1 = require("neverthrow");
+const base_repository_1 = require("#modules/base/base.repository");
+const recurrence = tslib_1.__importStar(require("#modules/recurrence/recurrence.db"));
+const schema = { ...recurrence };
+class RecurrenceRepository extends base_repository_1.BaseTableRepository {
+    async createWithRules(recurrenceData, rulesData, tx) {
+        return this.throwableAsync(async () => {
+            const db = tx ?? this.orm;
+            const result = await db.transaction(async (trx) => {
+                const [createdRecurrence] = await trx
+                    .insert(this.table)
+                    .values(recurrenceData)
+                    .returning();
+                if (!createdRecurrence)
+                    throw new Error("Failed to create recurrence");
+                const rulesWithRecurrenceId = rulesData.map((rule) => ({
+                    ...rule,
+                    recurrenceId: createdRecurrence.id,
+                }));
+                const insertedRules = rulesWithRecurrenceId.length > 0
+                    ? await trx
+                        .insert(this.schema.recurrenceRules)
+                        .values(rulesWithRecurrenceId)
+                        .returning()
+                    : [];
+                return (0, neverthrow_1.ok)({ recurrence: createdRecurrence, rules: insertedRules });
+            });
+            return result;
+        });
+    }
+}
+exports.RecurrenceRepository = RecurrenceRepository;
+class RecurrenceRulesRepository extends base_repository_1.BaseTableRepository {
+}
+exports.RecurrenceRulesRepository = RecurrenceRulesRepository;

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

@@ -0,0 +1,30 @@
+import type { CreateRecurrenceSchema, DeleteRecurrenceRulesSchema, DeleteRecurrenceSchema, UpdateRecurrenceRulesSchema, UpdateRecurrenceSchema } from "@m5kdev/commons/modules/recurrence/recurrence.schema";
+import type { QueryInput } from "@m5kdev/commons/modules/schemas/query.schema";
+import type { Context, User } from "#modules/auth/auth.lib";
+import type { ServerResultAsync } from "#modules/base/base.dto";
+import { BaseService } from "#modules/base/base.service";
+import type { CreateWithRulesResult, RecurrenceRepository, RecurrenceRulesRepository } from "#modules/recurrence/recurrence.repository";
+export declare class RecurrenceService extends BaseService<{
+    recurrence: RecurrenceRepository;
+    recurrenceRules: RecurrenceRulesRepository;
+}, Record<string, never>> {
+    create(data: CreateRecurrenceSchema, ctx: Context): ServerResultAsync<CreateWithRulesResult>;
+    list(query?: QueryInput, ctx?: {
+        user?: User;
+    }): ServerResultAsync<{
+        rows: CreateWithRulesResult["recurrence"][];
+        total: number;
+    }>;
+    findById(id: string): ServerResultAsync<CreateWithRulesResult["recurrence"] | null>;
+    update(data: UpdateRecurrenceSchema & {
+        id: string;
+    }): ServerResultAsync<CreateWithRulesResult["recurrence"]>;
+    updateRule(data: UpdateRecurrenceRulesSchema): ServerResultAsync<CreateWithRulesResult["rules"][number]>;
+    delete(data: DeleteRecurrenceSchema): ServerResultAsync<{
+        id: string;
+    }>;
+    deleteRule(data: DeleteRecurrenceRulesSchema): ServerResultAsync<{
+        id: string;
+    }>;
+}
+//# sourceMappingURL=recurrence.service.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"recurrence.service.d.ts","sourceRoot":"","sources":["../../../../src/modules/recurrence/recurrence.service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,sBAAsB,EACtB,2BAA2B,EAC3B,sBAAsB,EACtB,2BAA2B,EAC3B,sBAAsB,EACvB,MAAM,sDAAsD,CAAC;AAC9D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,8CAA8C,CAAC;AAE/E,OAAO,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,wBAAwB,CAAC;AAC5D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAChE,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AACzD,OAAO,KAAK,EAEV,qBAAqB,EACrB,oBAAoB,EACpB,yBAAyB,EAC1B,MAAM,2CAA2C,CAAC;AAiCnD,qBAAa,iBAAkB,SAAQ,WAAW,CAChD;IAAE,UAAU,EAAE,oBAAoB,CAAC;IAAC,eAAe,EAAE,yBAAyB,CAAA;CAAE,EAChF,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CACtB;IACO,MAAM,CACV,IAAI,EAAE,sBAAsB,EAC5B,GAAG,EAAE,OAAO,GACX,iBAAiB,CAAC,qBAAqB,CAAC;IAcrC,IAAI,CACR,KAAK,CAAC,EAAE,UAAU,EAClB,GAAG,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,IAAI,CAAA;KAAE,GACpB,iBAAiB,CAAC;QAAE,IAAI,EAAE,qBAAqB,CAAC,YAAY,CAAC,EAAE,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAK9E,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,iBAAiB,CAAC,qBAAqB,CAAC,YAAY,CAAC,GAAG,IAAI,CAAC;IAMnF,MAAM,CACV,IAAI,EAAE,sBAAsB,GAAG;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,GAC5C,iBAAiB,CAAC,qBAAqB,CAAC,YAAY,CAAC,CAAC;IAInD,UAAU,CACd,IAAI,EAAE,2BAA2B,GAChC,iBAAiB,CAAC,qBAAqB,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC;IAItD,MAAM,CAAC,IAAI,EAAE,sBAAsB,GAAG,iBAAiB,CAAC;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC;IAIvE,UAAU,CAAC,IAAI,EAAE,2BAA2B,GAAG,iBAAiB,CAAC;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC;CAGvF"}