brackets-prisma-db 1.0.0

package/README.md

@@ -0,0 +1,39 @@
+# brackets-prisma-db
+
+This implementation of the [`CrudInterface`](https://drarig29.github.io/brackets-docs/reference/manager/interfaces/CrudInterface.html)
+uses [prisma](https://www.prisma.io/) to store the data in an SQL Database.
+
+> **Warning**
+> This implementation has not been full tested yet. Use with caution.
+
+## Limitations
+
+Currently there are some features of the [manager](https://github.com/Drarig29/brackets-manager.js) that can't be used.
+
+| **Feature**         | **Status**      |
+| ------------------- | --------------- |
+| Custom Participants | Implemented     |
+| Custom Matches      | Not Implemented |
+
+## Usage
+
+To use this implementation make sure you have [prisma](https://www.prisma.io/) included in your project.
+A Guide on how to include prisma in your project can be found on the official documentation page.
+
+Once [prisma](https://www.prisma.io/) is included in your project copy the [`schema.prisma`](./prisma/schema.prisma) into your project.
+If you have an existing `schema.prisma` in your project copy and paste the schema definitions into your existing one.
+
+> **Warning**
+> Do not rename any of the models or enums provided! This **will** break the implementation.
+
+Next generate the prisma client using `npx prisma generate`.
+Lastly push the definition to your database using `npx prisma db push`.
+
+```typescript
+import { SqlDatabase } from 'brackets-prisma-db';
+import { prisma } from './client';
+import { BracketsManager } from 'brackets-manager';
+
+const storage = new SqlDatabase(prisma);
+const manager = new BracketsManager(storage);
+```

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,17 @@
+"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);

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

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

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleGroupDelete = void 0;
+async function handleGroupDelete(prisma, filter) {
+    // No filter so delete everything
+    if (!filter) {
+        return prisma.group
+            .deleteMany({})
+            .then(() => true)
+            .catch(() => false);
+    }
+    return prisma.group
+        .deleteMany({
+        where: {
+            id: filter.id,
+            stageId: filter.stage_id,
+            number: filter.number,
+        },
+    })
+        .then(() => true)
+        .catch(() => false);
+}
+exports.handleGroupDelete = handleGroupDelete;

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

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

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

@@ -0,0 +1,22 @@
+"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);

package/dist/storage-handlers/delete-handlers/match-game.d.ts

@@ -0,0 +1,3 @@
+import { DataTypes } from 'brackets-manager/dist/types';
+import { PrismaClient } from '@prisma/client';
+export declare function handleMatchGameDelete(prisma: PrismaClient, filter?: Partial<DataTypes['match_game']>): Promise<boolean>;

package/dist/storage-handlers/delete-handlers/match-game.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleMatchGameDelete = void 0;
+const transformers_1 = require("../../transformers");
+async function handleMatchGameDelete(prisma, filter) {
+    // No filter so delete everything
+    if (!filter) {
+        return prisma.matchGame
+            .deleteMany({})
+            .then(() => true)
+            .catch(() => false);
+    }
+    return prisma.matchGame
+        .deleteMany({
+        where: {
+            id: filter.id,
+            stageId: filter.stage_id,
+            matchId: filter.parent_id,
+            number: filter.number,
+            status: filter.status
+                ? transformers_1.MatchStatusTransformer.to(filter.status)
+                : undefined,
+        },
+    })
+        .then(() => true)
+        .catch(() => false);
+}
+exports.handleMatchGameDelete = handleMatchGameDelete;

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

@@ -0,0 +1,3 @@
+import { DataTypes } from 'brackets-manager/dist/types';
+import { PrismaClient } from '@prisma/client';
+export declare function handleMatchDelete(prisma: PrismaClient, filter?: Partial<DataTypes['match']>): Promise<boolean>;

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleMatchDelete = void 0;
+const transformers_1 = require("../../transformers");
+async function handleMatchDelete(prisma, filter) {
+    // No filter so delete everything
+    if (!filter) {
+        return prisma.match
+            .deleteMany({})
+            .then(() => true)
+            .catch(() => false);
+    }
+    return prisma.match
+        .deleteMany({
+        where: {
+            id: filter.id,
+            stageId: filter.stage_id,
+            groupId: filter.group_id,
+            roundId: filter.round_id,
+            number: filter.number,
+            status: filter.status
+                ? transformers_1.MatchStatusTransformer.to(filter.status)
+                : undefined,
+        },
+    })
+        .then(() => true)
+        .catch(() => false);
+}
+exports.handleMatchDelete = handleMatchDelete;

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

@@ -0,0 +1,3 @@
+import { PrismaClient } from '@prisma/client';
+import { DataTypes } from 'brackets-manager/dist/types';
+export declare function handleParticipantDelete(prisma: PrismaClient, filter?: Partial<DataTypes['participant']>): Promise<boolean>;

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleParticipantDelete = void 0;
+async function handleParticipantDelete(prisma, filter) {
+    // No filter so delete everything
+    if (!filter) {
+        return prisma.participant
+            .deleteMany({})
+            .then(() => true)
+            .catch(() => false);
+    }
+    return prisma.participant
+        .deleteMany({
+        where: {
+            id: filter.id,
+            name: filter.name,
+            tournamentId: filter.tournament_id,
+        },
+    })
+        .then(() => true)
+        .catch(() => false);
+}
+exports.handleParticipantDelete = handleParticipantDelete;

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

@@ -0,0 +1,3 @@
+import { DataTypes } from 'brackets-manager/dist/types';
+import { PrismaClient } from '@prisma/client';
+export declare function handleRoundDelete(prisma: PrismaClient, filter?: Partial<DataTypes['round']>): Promise<boolean>;

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleRoundDelete = void 0;
+async function handleRoundDelete(prisma, filter) {
+    // No filter so delete everything
+    if (!filter) {
+        return prisma.round
+            .deleteMany({})
+            .then(() => true)
+            .catch(() => false);
+    }
+    return prisma.round
+        .deleteMany({
+        where: {
+            id: filter.id,
+            stageId: filter.stage_id,
+            groupId: filter.group_id,
+            number: filter.number,
+        },
+    })
+        .then(() => true)
+        .catch(() => false);
+}
+exports.handleRoundDelete = handleRoundDelete;

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

@@ -0,0 +1,3 @@
+import { DataTypes } from 'brackets-manager/dist/types';
+import { PrismaClient } from '@prisma/client';
+export declare function handleStageDelete(prisma: PrismaClient, filter?: Partial<DataTypes['stage']>): Promise<boolean>;

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleStageDelete = void 0;
+const transformers_1 = require("../../transformers");
+async function handleStageDelete(prisma, filter) {
+    // No filter so delete everything
+    if (!filter) {
+        return prisma.stage
+            .deleteMany({})
+            .then(() => true)
+            .catch(() => false);
+    }
+    return prisma.stage
+        .deleteMany({
+        where: {
+            id: filter.id,
+            name: filter.name,
+            number: filter.number,
+            tournamentId: filter.tournament_id,
+            type: filter.type
+                ? transformers_1.StageTypeTransformer.to(filter.type)
+                : undefined,
+        },
+    })
+        .then(() => true)
+        .catch(() => false);
+}
+exports.handleStageDelete = handleStageDelete;

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

@@ -0,0 +1,3 @@
+import { DataTypes } from 'brackets-manager/dist/types';
+import { PrismaClient } from '@prisma/client';
+export declare function handleDelete<T extends keyof DataTypes>(prisma: PrismaClient, table: T, filter?: Partial<DataTypes[T]>): Promise<boolean>;

package/dist/storage-handlers/delete.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleDelete = void 0;
+const delete_handlers_1 = require("./delete-handlers");
+// Can't be named `delete` because its a reserved word...
+async function handleDelete(prisma, table, filter) {
+    switch (table) {
+        case 'participant':
+            return (0, delete_handlers_1.handleParticipantDelete)(prisma, filter);
+        case 'stage':
+            return (0, delete_handlers_1.handleStageDelete)(prisma, filter);
+        case 'group':
+            return (0, delete_handlers_1.handleGroupDelete)(prisma, filter);
+        case 'round':
+            return (0, delete_handlers_1.handleRoundDelete)(prisma, filter);
+        case 'match':
+            return (0, delete_handlers_1.handleMatchDelete)(prisma, filter);
+        case 'match_game':
+            return (0, delete_handlers_1.handleMatchGameDelete)(prisma, filter);
+        default:
+            return false;
+    }
+}
+exports.handleDelete = handleDelete;

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

@@ -0,0 +1,4 @@
+export * from './delete';
+export * from './insert';
+export * from './select';
+export * from './update';

package/dist/storage-handlers/index.js

@@ -0,0 +1,20 @@
+"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("./delete"), exports);
+__exportStar(require("./insert"), exports);
+__exportStar(require("./select"), exports);
+__exportStar(require("./update"), exports);

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

@@ -0,0 +1,3 @@
+import { DataTypes, OmitId } from 'brackets-manager/dist/types';
+import { PrismaClient } from '@prisma/client';
+export declare function handleGroupInsert(prisma: PrismaClient, values: OmitId<DataTypes['group']> | OmitId<DataTypes['group']>[]): Promise<number> | Promise<boolean>;

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleGroupInsert = void 0;
+const transformers_1 = require("../../transformers");
+function handleGroupInsert(prisma, values) {
+    if (Array.isArray(values)) {
+        return prisma.group
+            .createMany({
+            data: values.map(transformers_1.GroupTransformer.to),
+        })
+            .then(() => true)
+            .catch(() => false);
+    }
+    return prisma.group
+        .create({
+        data: transformers_1.GroupTransformer.to(values),
+    })
+        .then((v) => v.id)
+        .catch(() => -1);
+}
+exports.handleGroupInsert = handleGroupInsert;

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

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

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

@@ -0,0 +1,22 @@
+"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);

package/dist/storage-handlers/insert-handlers/match-game.d.ts

@@ -0,0 +1,3 @@
+import { DataTypes, OmitId } from 'brackets-manager/dist/types';
+import { PrismaClient } from '@prisma/client';
+export declare function handleMatchGameInsert(prisma: PrismaClient, values: OmitId<DataTypes['match_game']> | OmitId<DataTypes['match_game']>[]): Promise<number> | Promise<boolean>;

package/dist/storage-handlers/insert-handlers/match-game.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleMatchGameInsert = void 0;
+const transformers_1 = require("../../transformers");
+function getCreationData(value) {
+    return {
+        ...transformers_1.MatchGameTransformer.to(value),
+        opponent1Result: value.opponent1
+            ? {
+                create: {
+                    participantId: value.opponent1.id,
+                    forfeit: value.opponent1.forfeit,
+                    position: value.opponent1.position,
+                    score: value.opponent1.score,
+                    result: value.opponent1.result
+                        ? transformers_1.MatchResultTransformer.to(value.opponent1.result)
+                        : undefined,
+                },
+            }
+            : undefined,
+        opponent2Result: value.opponent2
+            ? {
+                create: {
+                    participantId: value.opponent2.id,
+                    forfeit: value.opponent2.forfeit,
+                    position: value.opponent2.position,
+                    score: value.opponent2.score,
+                    result: value.opponent2.result
+                        ? transformers_1.MatchResultTransformer.to(value.opponent2.result)
+                        : undefined,
+                },
+            }
+            : undefined,
+    };
+}
+function handleMatchGameInsert(prisma, values) {
+    if (Array.isArray(values)) {
+        return prisma.matchGame
+            .createMany({
+            data: values.map((v) => getCreationData(v)),
+        })
+            .then(() => true)
+            .catch(() => false);
+    }
+    return prisma.matchGame
+        .create({
+        data: getCreationData(values),
+    })
+        .then((v) => v.id)
+        .catch(() => -1);
+}
+exports.handleMatchGameInsert = handleMatchGameInsert;

package/dist/storage-handlers/insert-handlers/match.d.ts

@@ -0,0 +1,3 @@
+import { DataTypes, OmitId } from 'brackets-manager/dist/types';
+import { PrismaClient } from '@prisma/client';
+export declare function handleMatchInsert(prisma: PrismaClient, values: OmitId<DataTypes['match']> | OmitId<DataTypes['match']>[]): Promise<number> | Promise<boolean>;

package/dist/storage-handlers/insert-handlers/match.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleMatchInsert = void 0;
+const transformers_1 = require("../../transformers");
+function getCreationData(value) {
+    return {
+        ...transformers_1.MatchTransformer.to(value),
+        opponent1Result: value.opponent1
+            ? {
+                create: {
+                    participantId: value.opponent1.id,
+                    forfeit: value.opponent1.forfeit,
+                    position: value.opponent1.position,
+                    score: value.opponent1.score,
+                    result: value.opponent1.result
+                        ? transformers_1.MatchResultTransformer.to(value.opponent1.result)
+                        : undefined,
+                },
+            }
+            : undefined,
+        opponent2Result: value.opponent2
+            ? {
+                create: {
+                    participantId: value.opponent2.id,
+                    forfeit: value.opponent2.forfeit,
+                    position: value.opponent2.position,
+                    score: value.opponent2.score,
+                    result: value.opponent2.result
+                        ? transformers_1.MatchResultTransformer.to(value.opponent2.result)
+                        : undefined,
+                },
+            }
+            : undefined,
+    };
+}
+function handleMatchInsert(prisma, values) {
+    if (Array.isArray(values)) {
+        return prisma.match
+            .createMany({
+            data: values.map((v) => getCreationData(v)),
+        })
+            .then(() => true)
+            .catch(() => false);
+    }
+    return prisma.match
+        .create({
+        data: getCreationData(values),
+    })
+        .then((v) => v.id)
+        .catch(() => -1);
+}
+exports.handleMatchInsert = handleMatchInsert;

package/dist/storage-handlers/insert-handlers/participant.d.ts

@@ -0,0 +1,3 @@
+import { DataTypes, OmitId } from 'brackets-manager/dist/types';
+import { PrismaClient } from '@prisma/client';
+export declare function handleParticipantInsert(prisma: PrismaClient, values: OmitId<DataTypes['participant']> | OmitId<DataTypes['participant']>[]): Promise<number> | Promise<boolean>;

package/dist/storage-handlers/insert-handlers/participant.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleParticipantInsert = void 0;
+const transformers_1 = require("../../transformers");
+function handleParticipantInsert(prisma, values) {
+    if (Array.isArray(values)) {
+        return prisma.participant
+            .createMany({
+            data: values.map(transformers_1.ParticipantTransformer.to),
+        })
+            .then(() => true)
+            .catch(() => false);
+    }
+    return prisma.participant
+        .create({
+        data: transformers_1.ParticipantTransformer.to(values),
+    })
+        .then((v) => v.id)
+        .catch(() => -1);
+}
+exports.handleParticipantInsert = handleParticipantInsert;

package/dist/storage-handlers/insert-handlers/round.d.ts

@@ -0,0 +1,3 @@
+import { DataTypes, OmitId } from 'brackets-manager/dist/types';
+import { PrismaClient } from '@prisma/client';
+export declare function handleRoundInsert(prisma: PrismaClient, values: OmitId<DataTypes['round']> | OmitId<DataTypes['round']>[]): Promise<number> | Promise<boolean>;

package/dist/storage-handlers/insert-handlers/round.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleRoundInsert = void 0;
+const transformers_1 = require("../../transformers");
+function handleRoundInsert(prisma, values) {
+    if (Array.isArray(values)) {
+        return prisma.round
+            .createMany({
+            data: values.map(transformers_1.RoundTransformer.to),
+        })
+            .then(() => true)
+            .catch(() => false);
+    }
+    return prisma.round
+        .create({
+        data: transformers_1.RoundTransformer.to(values),
+    })
+        .then((v) => v.id)
+        .catch(() => -1);
+}
+exports.handleRoundInsert = handleRoundInsert;

package/dist/storage-handlers/insert-handlers/stage.d.ts

@@ -0,0 +1,3 @@
+import { DataTypes, OmitId } from 'brackets-manager/dist/types';
+import { PrismaClient } from '@prisma/client';
+export declare function handleStageInsert(prisma: PrismaClient, values: OmitId<DataTypes['stage']> | OmitId<DataTypes['stage']>[]): Promise<number> | Promise<boolean>;

package/dist/storage-handlers/insert-handlers/stage.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleStageInsert = void 0;
+const transformers_1 = require("../../transformers");
+function handleStageInsert(prisma, values) {
+    if (Array.isArray(values)) {
+        return prisma.stage
+            .createMany({
+            data: values.map((v) => ({
+                ...transformers_1.StageTransformer.to(v),
+                settings: {
+                    create: {
+                        ...transformers_1.StageSettingsTransformer.to(v.settings),
+                    },
+                },
+            })),
+        })
+            .then(() => true)
+            .catch(() => false);
+    }
+    return prisma.stage
+        .create({
+        data: {
+            ...transformers_1.StageTransformer.to(values),
+            settings: {
+                create: {
+                    ...transformers_1.StageSettingsTransformer.to(values.settings),
+                },
+            },
+        },
+    })
+        .then((v) => v.id)
+        .catch(() => -1);
+}
+exports.handleStageInsert = handleStageInsert;

package/dist/storage-handlers/insert.d.ts

@@ -0,0 +1,3 @@
+import { DataTypes, OmitId } from 'brackets-manager/dist/types';
+import { PrismaClient } from '@prisma/client';
+export declare function handleInsert<T extends keyof DataTypes>(prisma: PrismaClient, table: T, values: OmitId<DataTypes[T]> | OmitId<DataTypes[T]>[]): Promise<number | boolean>;

package/dist/storage-handlers/insert.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleInsert = void 0;
+const insert_handlers_1 = require("./insert-handlers");
+async function handleInsert(prisma, table, values) {
+    switch (table) {
+        case 'participant':
+            const participantValues = values;
+            return (0, insert_handlers_1.handleParticipantInsert)(prisma, participantValues);
+        case 'stage':
+            const stageValues = values;
+            return (0, insert_handlers_1.handleStageInsert)(prisma, stageValues);
+        case 'group':
+            const groupValues = values;
+            return (0, insert_handlers_1.handleGroupInsert)(prisma, groupValues);
+        case 'round':
+            const roundValues = values;
+            return (0, insert_handlers_1.handleRoundInsert)(prisma, roundValues);
+        case 'match':
+            const matchValues = values;
+            return (0, insert_handlers_1.handleMatchInsert)(prisma, matchValues);
+        case 'match_game':
+            const matchGameValues = values;
+            return (0, insert_handlers_1.handleMatchGameInsert)(prisma, matchGameValues);
+        default:
+            return false;
+    }
+}
+exports.handleInsert = handleInsert;