brackets-drizzle-db 2.1.0

package/dist/db/schema/round.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.roundRelations = exports.round = void 0;
+const pg_core_1 = require("drizzle-orm/pg-core");
+const drizzle_orm_1 = require("drizzle-orm");
+const stage_1 = require("./stage");
+const group_1 = require("./group");
+const match_1 = require("./match");
+// A round of a group.
+exports.round = (0, pg_core_1.pgTable)('Round', {
+    id: (0, pg_core_1.text)('id').primaryKey(),
+    // ID of the parent stage.
+    stageId: (0, pg_core_1.text)('stageId')
+        .notNull()
+        .references(() => stage_1.stage.id),
+    // ID of the parent group.
+    groupId: (0, pg_core_1.text)('groupId')
+        .notNull()
+        .references(() => group_1.group.id),
+    // The number of the round in its group
+    number: (0, pg_core_1.integer)('number').notNull(),
+});
+exports.roundRelations = (0, drizzle_orm_1.relations)(exports.round, ({ one, many }) => ({
+    stage: one(stage_1.stage, {
+        fields: [exports.round.stageId],
+        references: [stage_1.stage.id],
+    }),
+    group: one(group_1.group, {
+        fields: [exports.round.groupId],
+        references: [group_1.group.id],
+    }),
+    matches: many(match_1.match),
+}));

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

@@ -0,0 +1,344 @@
+export declare const stage: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "Stage";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "Stage";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        tournamentId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "tournamentId";
+            tableName: "Stage";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        name: import("drizzle-orm/pg-core").PgColumn<{
+            name: "name";
+            tableName: "Stage";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        type: import("drizzle-orm/pg-core").PgColumn<{
+            name: "type";
+            tableName: "Stage";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "ROUND_ROBIN" | "SINGLE_ELIMINATION" | "DOUBLE_ELIMINATION";
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["ROUND_ROBIN", "SINGLE_ELIMINATION", "DOUBLE_ELIMINATION"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        number: import("drizzle-orm/pg-core").PgColumn<{
+            name: "number";
+            tableName: "Stage";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export declare const stageRelations: import("drizzle-orm").Relations<"Stage", {
+    tournament: import("drizzle-orm").One<"Tournament", true>;
+    settings: import("drizzle-orm").One<"StageSettings", true>;
+    groups: import("drizzle-orm").Many<"Group">;
+    rounds: import("drizzle-orm").Many<"Round">;
+    matches: import("drizzle-orm").Many<"Match">;
+    matchGames: import("drizzle-orm").Many<"MatchGame">;
+}>;
+export declare const stageSettings: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "StageSettings";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "StageSettings";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        stageId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "stageId";
+            tableName: "StageSettings";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        size: import("drizzle-orm/pg-core").PgColumn<{
+            name: "size";
+            tableName: "StageSettings";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        seedOrdering: import("drizzle-orm/pg-core").PgColumn<{
+            name: "seedOrdering";
+            tableName: "StageSettings";
+            dataType: "array";
+            columnType: "PgArray";
+            data: ("NATURAL" | "REVERSE" | "HALF_SHIFT" | "REVERSE_HALF_SHIFT" | "PAIR_FLIP" | "INNER_OUTER" | "GROUPS_EFFORT_BALANCED" | "GROUPS_SEED_OPTIMIZED" | "GROUPS_BRACKET_OPTIMIZED")[];
+            driverParam: string | string[];
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["NATURAL", "REVERSE", "HALF_SHIFT", "REVERSE_HALF_SHIFT", "PAIR_FLIP", "INNER_OUTER", "GROUPS_EFFORT_BALANCED", "GROUPS_SEED_OPTIMIZED", "GROUPS_BRACKET_OPTIMIZED"];
+            baseColumn: import("drizzle-orm").Column<{
+                name: "seedOrdering";
+                tableName: "StageSettings";
+                dataType: "string";
+                columnType: "PgEnumColumn";
+                data: "NATURAL" | "REVERSE" | "HALF_SHIFT" | "REVERSE_HALF_SHIFT" | "PAIR_FLIP" | "INNER_OUTER" | "GROUPS_EFFORT_BALANCED" | "GROUPS_SEED_OPTIMIZED" | "GROUPS_BRACKET_OPTIMIZED";
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: ["NATURAL", "REVERSE", "HALF_SHIFT", "REVERSE_HALF_SHIFT", "PAIR_FLIP", "INNER_OUTER", "GROUPS_EFFORT_BALANCED", "GROUPS_SEED_OPTIMIZED", "GROUPS_BRACKET_OPTIMIZED"];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            size: undefined;
+            baseBuilder: import("drizzle-orm/pg-core").PgColumnBuilder<{
+                name: "seedOrdering";
+                dataType: "string";
+                columnType: "PgEnumColumn";
+                data: "NATURAL" | "REVERSE" | "HALF_SHIFT" | "REVERSE_HALF_SHIFT" | "PAIR_FLIP" | "INNER_OUTER" | "GROUPS_EFFORT_BALANCED" | "GROUPS_SEED_OPTIMIZED" | "GROUPS_BRACKET_OPTIMIZED";
+                enumValues: ["NATURAL", "REVERSE", "HALF_SHIFT", "REVERSE_HALF_SHIFT", "PAIR_FLIP", "INNER_OUTER", "GROUPS_EFFORT_BALANCED", "GROUPS_SEED_OPTIMIZED", "GROUPS_BRACKET_OPTIMIZED"];
+                driverParam: string;
+            }, {}, {}, import("drizzle-orm").ColumnBuilderExtraConfig>;
+        }>;
+        balanceByes: import("drizzle-orm/pg-core").PgColumn<{
+            name: "balanceByes";
+            tableName: "StageSettings";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        matchesChildCount: import("drizzle-orm/pg-core").PgColumn<{
+            name: "matchesChildCount";
+            tableName: "StageSettings";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        groupCount: import("drizzle-orm/pg-core").PgColumn<{
+            name: "groupCount";
+            tableName: "StageSettings";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        roundRobinMode: import("drizzle-orm/pg-core").PgColumn<{
+            name: "roundRobinMode";
+            tableName: "StageSettings";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "SIMPLE" | "DOUBLE";
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["SIMPLE", "DOUBLE"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        manualOrdering: import("drizzle-orm/pg-core").PgColumn<{
+            name: "manualOrdering";
+            tableName: "StageSettings";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        consolationFinal: import("drizzle-orm/pg-core").PgColumn<{
+            name: "consolationFinal";
+            tableName: "StageSettings";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        skipFirstRound: import("drizzle-orm/pg-core").PgColumn<{
+            name: "skipFirstRound";
+            tableName: "StageSettings";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        grandFinal: import("drizzle-orm/pg-core").PgColumn<{
+            name: "grandFinal";
+            tableName: "StageSettings";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "NONE" | "SIMPLE" | "DOUBLE";
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["NONE", "SIMPLE", "DOUBLE"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export declare const stageSettingsRelations: import("drizzle-orm").Relations<"StageSettings", {
+    stage: import("drizzle-orm").One<"Stage", true>;
+}>;
+export type Stage = typeof stage.$inferSelect;
+export type NewStage = typeof stage.$inferInsert;
+export type StageSettings = typeof stageSettings.$inferSelect;
+export type NewStageSettings = typeof stageSettings.$inferInsert;

package/dist/db/schema/stage.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stageSettingsRelations = exports.stageSettings = exports.stageRelations = exports.stage = void 0;
+const pg_core_1 = require("drizzle-orm/pg-core");
+const drizzle_orm_1 = require("drizzle-orm");
+const enums_1 = require("./enums");
+const tournament_1 = require("./tournament");
+const group_1 = require("./group");
+const round_1 = require("./round");
+const match_1 = require("./match");
+const match_game_1 = require("./match-game");
+// A stage, which can be a round-robin stage or a single/double elimination stage.
+exports.stage = (0, pg_core_1.pgTable)('Stage', {
+    id: (0, pg_core_1.text)('id').primaryKey(),
+    tournamentId: (0, pg_core_1.text)('tournamentId')
+        .notNull()
+        .references(() => tournament_1.tournament.id),
+    // Name of the stage
+    name: (0, pg_core_1.text)('name').notNull(),
+    // Type of the stage
+    type: (0, enums_1.stageTypeEnum)('type').notNull(),
+    // The number of the stage in its tournament
+    number: (0, pg_core_1.integer)('number').notNull(),
+});
+exports.stageRelations = (0, drizzle_orm_1.relations)(exports.stage, ({ one, many }) => ({
+    tournament: one(tournament_1.tournament, {
+        fields: [exports.stage.tournamentId],
+        references: [tournament_1.tournament.id],
+    }),
+    settings: one(exports.stageSettings, {
+        fields: [exports.stage.id],
+        references: [exports.stageSettings.stageId],
+    }),
+    groups: many(group_1.group),
+    rounds: many(round_1.round),
+    matches: many(match_1.match),
+    matchGames: many(match_game_1.matchGame),
+}));
+// The possible settings for a stage.
+exports.stageSettings = (0, pg_core_1.pgTable)('StageSettings', {
+    id: (0, pg_core_1.text)('id').primaryKey(),
+    stageId: (0, pg_core_1.text)('stageId')
+        .notNull()
+        .unique()
+        .references(() => exports.stage.id),
+    // The number of participants
+    size: (0, pg_core_1.integer)('size'),
+    // A list of ordering methods to apply to the seeding.
+    seedOrdering: (0, enums_1.seedOrderingEnum)('seedOrdering').array(),
+    // Whether to balance BYEs in the seeding of an elimination stage.
+    balanceByes: (0, pg_core_1.boolean)('balanceByes'),
+    // All matches of the stage will have this child count.
+    matchesChildCount: (0, pg_core_1.integer)('matchesChildCount'),
+    // Number of groups in a round-robin stage.
+    groupCount: (0, pg_core_1.integer)('groupCount'),
+    // The mode for the round-robin stage.
+    roundRobinMode: (0, enums_1.roundRobinModeEnum)('roundRobinMode'),
+    // A list of seeds per group for a round-robin stage to be manually ordered.
+    manualOrdering: (0, pg_core_1.jsonb)('manualOrdering'),
+    // Optional final between semi-final losers.
+    consolationFinal: (0, pg_core_1.boolean)('consolationFinal'),
+    // Whether to skip the first round of the WB of a double elimination stage.
+    skipFirstRound: (0, pg_core_1.boolean)('skipFirstRound'),
+    // Optional grand final between WB and LB winners.
+    grandFinal: (0, enums_1.grandFinalTypeEnum)('grandFinal'),
+});
+exports.stageSettingsRelations = (0, drizzle_orm_1.relations)(exports.stageSettings, ({ one }) => ({
+    stage: one(exports.stage, {
+        fields: [exports.stageSettings.stageId],
+        references: [exports.stage.id],
+    }),
+}));

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

@@ -0,0 +1,115 @@
+export declare const tournament: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "Tournament";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "Tournament";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        name: import("drizzle-orm/pg-core").PgColumn<{
+            name: "name";
+            tableName: "Tournament";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        description: import("drizzle-orm/pg-core").PgColumn<{
+            name: "description";
+            tableName: "Tournament";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        startDate: import("drizzle-orm/pg-core").PgColumn<{
+            name: "startDate";
+            tableName: "Tournament";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        endDate: import("drizzle-orm/pg-core").PgColumn<{
+            name: "endDate";
+            tableName: "Tournament";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        extra: import("drizzle-orm/pg-core").PgColumn<{
+            name: "extra";
+            tableName: "Tournament";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export declare const tournamentRelations: import("drizzle-orm").Relations<"Tournament", {
+    stages: import("drizzle-orm").Many<"Stage">;
+    participants: import("drizzle-orm").Many<"Participant">;
+}>;
+export type Tournament = typeof tournament.$inferSelect;
+export type NewTournament = typeof tournament.$inferInsert;

package/dist/db/schema/tournament.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tournamentRelations = exports.tournament = void 0;
+const pg_core_1 = require("drizzle-orm/pg-core");
+const drizzle_orm_1 = require("drizzle-orm");
+const stage_1 = require("./stage");
+const participant_1 = require("./participant");
+// A tournament that can contain multiple stages and participants.
+exports.tournament = (0, pg_core_1.pgTable)('Tournament', {
+    id: (0, pg_core_1.text)('id').primaryKey(),
+    // Name of the tournament
+    name: (0, pg_core_1.text)('name').notNull(),
+    // Description of the tournament
+    description: (0, pg_core_1.text)('description'),
+    // Start date of the tournament
+    startDate: (0, pg_core_1.timestamp)('startDate'),
+    // End date of the tournament
+    endDate: (0, pg_core_1.timestamp)('endDate'),
+    // Additional data for the tournament
+    extra: (0, pg_core_1.jsonb)('extra'),
+});
+exports.tournamentRelations = (0, drizzle_orm_1.relations)(exports.tournament, ({ many }) => ({
+    stages: many(stage_1.stage),
+    participants: many(participant_1.participant),
+}));

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './storage';
+export * from './db';
+export * from './db/schema';

package/dist/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./storage"), exports);
+__exportStar(require("./db"), exports);
+__exportStar(require("./db/schema"), exports);

package/dist/storage-handlers/delete-handlers/group.d.ts

@@ -0,0 +1,3 @@
+import { DataTypes } from 'brackets-manager/dist/types';
+import type { DrizzleDatabase } from '../../db';
+export declare function handleGroupDelete(db: DrizzleDatabase, filter?: Partial<DataTypes['group']>): Promise<boolean>;

package/dist/storage-handlers/delete-handlers/group.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleGroupDelete = handleGroupDelete;
+const schema_1 = require("../../db/schema");
+const drizzle_orm_1 = require("drizzle-orm");
+async function handleGroupDelete(db, filter) {
+    try {
+        if (!filter) {
+            await db.delete(schema_1.group);
+            return true;
+        }
+        const conditions = [];
+        if (filter.id !== undefined)
+            conditions.push((0, drizzle_orm_1.eq)(schema_1.group.id, String(filter.id)));
+        if (filter.stage_id !== undefined)
+            conditions.push((0, drizzle_orm_1.eq)(schema_1.group.stageId, String(filter.stage_id)));
+        if (filter.number !== undefined)
+            conditions.push((0, drizzle_orm_1.eq)(schema_1.group.number, filter.number));
+        await db
+            .delete(schema_1.group)
+            .where(conditions.length > 0 ? (0, drizzle_orm_1.and)(...conditions) : undefined);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/storage-handlers/delete-handlers/index.d.ts

@@ -0,0 +1,7 @@
+export * from './group';
+export * from './match';
+export * from './match-game';
+export * from './participant';
+export * from './round';
+export * from './stage';
+export * from './tournament';

package/dist/storage-handlers/delete-handlers/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./group"), exports);
+__exportStar(require("./match"), exports);
+__exportStar(require("./match-game"), exports);
+__exportStar(require("./participant"), exports);
+__exportStar(require("./round"), exports);
+__exportStar(require("./stage"), exports);
+__exportStar(require("./tournament"), exports);