@mshowes/brackets-manager 1.8.5 → 1.8.7

package/dist/storage/drizzle/db/index.js

@@ -0,0 +1,15 @@
+import { drizzle } from 'drizzle-orm/postgres-js';
+import postgres from 'postgres';
+import * as schema from './schema';
+/**
+ * Creates a Drizzle database instance connected to PostgreSQL.
+ *
+ * @param connectionString - PostgreSQL connection string
+ * @returns Drizzle database instance with schema
+ */
+export function createDatabase(connectionString) {
+    const client = postgres(connectionString);
+    return drizzle(client, { schema });
+}
+export { schema };
+//# sourceMappingURL=index.js.map

package/dist/storage/drizzle/db/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/storage/drizzle/db/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAA2B,MAAM,yBAAyB,CAAC;AAC3E,OAAO,QAAQ,MAAM,UAAU,CAAC;AAChC,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AAInC;;;;;GAKG;AACH,MAAM,UAAU,cAAc,CAAC,gBAAwB;IACnD,MAAM,MAAM,GAAG,QAAQ,CAAC,gBAAgB,CAAC,CAAC;IAC1C,OAAO,OAAO,CAAC,MAAM,EAAE,EAAE,MAAM,EAAE,CAAC,CAAC;AACvC,CAAC;AAED,OAAO,EAAE,MAAM,EAAE,CAAC"}

package/dist/storage/drizzle/db/schema/enums.d.ts

@@ -0,0 +1,6 @@
+export declare const stageTypeEnum: import("drizzle-orm/pg-core").PgEnum<["round_robin", "single_elimination", "double_elimination"]>;
+export declare const grandFinalTypeEnum: import("drizzle-orm/pg-core").PgEnum<["none", "simple", "double"]>;
+export declare const roundRobinModeEnum: import("drizzle-orm/pg-core").PgEnum<["simple", "double"]>;
+export declare const seedOrderingEnum: import("drizzle-orm/pg-core").PgEnum<["natural", "reverse", "half_shift", "reverse_half_shift", "pair_flip", "inner_outer", "groups.effort_balanced", "groups.seed_optimized", "groups.bracket_optimized"]>;
+export declare const matchResultEnum: import("drizzle-orm/pg-core").PgEnum<["win", "draw", "loss"]>;
+//# sourceMappingURL=enums.d.ts.map

package/dist/storage/drizzle/db/schema/enums.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enums.d.ts","sourceRoot":"","sources":["../../../../../src/storage/drizzle/db/schema/enums.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,aAAa,mGAIxB,CAAC;AAGH,eAAO,MAAM,kBAAkB,oEAI7B,CAAC;AAGH,eAAO,MAAM,kBAAkB,4DAAmD,CAAC;AAGnF,eAAO,MAAM,gBAAgB,6MAU3B,CAAC;AAGH,eAAO,MAAM,eAAe,+DAAkD,CAAC"}

package/dist/storage/drizzle/db/schema/enums.js

@@ -0,0 +1,30 @@
+import { pgEnum } from 'drizzle-orm/pg-core';
+// The only supported types of stage.
+export const stageTypeEnum = pgEnum('stage_type', [
+    'round_robin',
+    'single_elimination',
+    'double_elimination',
+]);
+// The possible types for a double elimination stage's grand final.
+export const grandFinalTypeEnum = pgEnum('grand_final_type', [
+    'none',
+    'simple',
+    'double',
+]);
+// The possible modes for a round-robin stage.
+export const roundRobinModeEnum = pgEnum('round_robin_mode', ['simple', 'double']);
+// Used to order seeds.
+export const seedOrderingEnum = pgEnum('seed_ordering', [
+    'natural',
+    'reverse',
+    'half_shift',
+    'reverse_half_shift',
+    'pair_flip',
+    'inner_outer',
+    'groups.effort_balanced',
+    'groups.seed_optimized',
+    'groups.bracket_optimized',
+]);
+// The possible results of a duel for a participant.
+export const matchResultEnum = pgEnum('match_result', ['win', 'draw', 'loss']);
+//# sourceMappingURL=enums.js.map

package/dist/storage/drizzle/db/schema/enums.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"enums.js","sourceRoot":"","sources":["../../../../../src/storage/drizzle/db/schema/enums.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAE7C,qCAAqC;AACrC,MAAM,CAAC,MAAM,aAAa,GAAG,MAAM,CAAC,YAAY,EAAE;IAC9C,aAAa;IACb,oBAAoB;IACpB,oBAAoB;CACvB,CAAC,CAAC;AAEH,mEAAmE;AACnE,MAAM,CAAC,MAAM,kBAAkB,GAAG,MAAM,CAAC,kBAAkB,EAAE;IACzD,MAAM;IACN,QAAQ;IACR,QAAQ;CACX,CAAC,CAAC;AAEH,8CAA8C;AAC9C,MAAM,CAAC,MAAM,kBAAkB,GAAG,MAAM,CAAC,kBAAkB,EAAE,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC;AAEnF,uBAAuB;AACvB,MAAM,CAAC,MAAM,gBAAgB,GAAG,MAAM,CAAC,eAAe,EAAE;IACpD,SAAS;IACT,SAAS;IACT,YAAY;IACZ,oBAAoB;IACpB,WAAW;IACX,aAAa;IACb,wBAAwB;IACxB,uBAAuB;IACvB,0BAA0B;CAC7B,CAAC,CAAC;AAEH,oDAAoD;AACpD,MAAM,CAAC,MAAM,eAAe,GAAG,MAAM,CAAC,cAAc,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC"}

package/dist/storage/drizzle/db/schema/group.d.ts

@@ -0,0 +1,66 @@
+export declare const group: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "group";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "group";
+            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;
+        }, {}, {}>;
+        stage_id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "stage_id";
+            tableName: "group";
+            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;
+        }, {}, {}>;
+        number: import("drizzle-orm/pg-core").PgColumn<{
+            name: "number";
+            tableName: "group";
+            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 groupRelations: import("drizzle-orm").Relations<"group", {
+    stage: import("drizzle-orm").One<"stage", true>;
+    rounds: import("drizzle-orm").Many<"round">;
+    matches: import("drizzle-orm").Many<"match">;
+}>;
+export type Group = typeof group.$inferSelect;
+export type NewGroup = typeof group.$inferInsert;
+//# sourceMappingURL=group.d.ts.map

package/dist/storage/drizzle/db/schema/group.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"group.d.ts","sourceRoot":"","sources":["../../../../../src/storage/drizzle/db/schema/group.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQhB,CAAC;AAEH,eAAO,MAAM,cAAc;;;;EAOxB,CAAC;AAEJ,MAAM,MAAM,KAAK,GAAG,OAAO,KAAK,CAAC,YAAY,CAAC;AAC9C,MAAM,MAAM,QAAQ,GAAG,OAAO,KAAK,CAAC,YAAY,CAAC"}

package/dist/storage/drizzle/db/schema/group.js

@@ -0,0 +1,24 @@
+import { integer, pgTable, text } from 'drizzle-orm/pg-core';
+import { relations } from 'drizzle-orm';
+import { stage } from './stage';
+import { round } from './round';
+import { match } from './match';
+// A group of a stage.
+export const group = pgTable('group', {
+    id: text('id').primaryKey(),
+    // ID of the parent stage.
+    stage_id: text('stage_id')
+        .notNull()
+        .references(() => stage.id),
+    // The number of the group in its stage
+    number: integer('number').notNull(),
+});
+export const groupRelations = relations(group, ({ one, many }) => ({
+    stage: one(stage, {
+        fields: [group.stage_id],
+        references: [stage.id],
+    }),
+    rounds: many(round),
+    matches: many(match),
+}));
+//# sourceMappingURL=group.js.map

package/dist/storage/drizzle/db/schema/group.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"group.js","sourceRoot":"","sources":["../../../../../src/storage/drizzle/db/schema/group.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC,sBAAsB;AACtB,MAAM,CAAC,MAAM,KAAK,GAAG,OAAO,CAAC,OAAO,EAAE;IAClC,EAAE,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC,UAAU,EAAE;IAC3B,0BAA0B;IAC1B,QAAQ,EAAE,IAAI,CAAC,UAAU,CAAC;SACrB,OAAO,EAAE;SACT,UAAU,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC;IAC/B,uCAAuC;IACvC,MAAM,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC,OAAO,EAAE;CACtC,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,cAAc,GAAG,SAAS,CAAC,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,CAAC;IAC/D,KAAK,EAAE,GAAG,CAAC,KAAK,EAAE;QACd,MAAM,EAAE,CAAC,KAAK,CAAC,QAAQ,CAAC;QACxB,UAAU,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC;KACzB,CAAC;IACF,MAAM,EAAE,IAAI,CAAC,KAAK,CAAC;IACnB,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC;CACvB,CAAC,CAAC,CAAC"}

package/dist/storage/drizzle/db/schema/index.d.ts

@@ -0,0 +1,9 @@
+export * from './enums';
+export * from './tournament';
+export * from './participant';
+export * from './stage';
+export * from './group';
+export * from './round';
+export * from './match';
+export * from './match-game';
+//# sourceMappingURL=index.d.ts.map

package/dist/storage/drizzle/db/schema/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/storage/drizzle/db/schema/index.ts"],"names":[],"mappings":"AACA,cAAc,SAAS,CAAC;AAGxB,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,cAAc,CAAC"}

package/dist/storage/drizzle/db/schema/index.js

@@ -0,0 +1,11 @@
+// Enums
+export * from './enums';
+// Tables and relations
+export * from './tournament';
+export * from './participant';
+export * from './stage';
+export * from './group';
+export * from './round';
+export * from './match';
+export * from './match-game';
+//# sourceMappingURL=index.js.map

package/dist/storage/drizzle/db/schema/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/storage/drizzle/db/schema/index.ts"],"names":[],"mappings":"AAAA,QAAQ;AACR,cAAc,SAAS,CAAC;AAExB,uBAAuB;AACvB,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,cAAc,CAAC"}

package/dist/storage/drizzle/db/schema/match-game.d.ts

@@ -0,0 +1,138 @@
+import type { ParticipantResult } from '../../../../model';
+export declare const matchGame: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "match_game";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "match_game";
+            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;
+        }, {}, {}>;
+        stage_id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "stage_id";
+            tableName: "match_game";
+            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;
+        }, {}, {}>;
+        parent_id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "parent_id";
+            tableName: "match_game";
+            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;
+        }, {}, {}>;
+        number: import("drizzle-orm/pg-core").PgColumn<{
+            name: "number";
+            tableName: "match_game";
+            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;
+        }, {}, {}>;
+        status: import("drizzle-orm/pg-core").PgColumn<{
+            name: "status";
+            tableName: "match_game";
+            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;
+        }, {}, {}>;
+        opponent1: import("drizzle-orm/pg-core").PgColumn<{
+            name: "opponent1";
+            tableName: "match_game";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: ParticipantResult | null;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: ParticipantResult | null;
+        }>;
+        opponent2: import("drizzle-orm/pg-core").PgColumn<{
+            name: "opponent2";
+            tableName: "match_game";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: ParticipantResult | null;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: ParticipantResult | null;
+        }>;
+    };
+    dialect: "pg";
+}>;
+export declare const matchGameRelations: import("drizzle-orm").Relations<"match_game", {
+    stage: import("drizzle-orm").One<"stage", true>;
+    match: import("drizzle-orm").One<"match", true>;
+}>;
+export type MatchGame = typeof matchGame.$inferSelect;
+export type NewMatchGame = typeof matchGame.$inferInsert;
+//# sourceMappingURL=match-game.d.ts.map

package/dist/storage/drizzle/db/schema/match-game.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"match-game.d.ts","sourceRoot":"","sources":["../../../../../src/storage/drizzle/db/schema/match-game.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAGjD,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkBpB,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;EAS5B,CAAC;AAEJ,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAC,YAAY,CAAC;AACtD,MAAM,MAAM,YAAY,GAAG,OAAO,SAAS,CAAC,YAAY,CAAC"}

package/dist/storage/drizzle/db/schema/match-game.js

@@ -0,0 +1,35 @@
+import { integer, jsonb, pgTable, text } from 'drizzle-orm/pg-core';
+import { relations } from 'drizzle-orm';
+import { stage } from './stage';
+import { match } from './match';
+// A game within a match.
+export const matchGame = pgTable('match_game', {
+    id: text('id').primaryKey(),
+    // ID of the parent stage.
+    stage_id: text('stage_id')
+        .notNull()
+        .references(() => stage.id),
+    // ID of the parent match.
+    parent_id: text('parent_id')
+        .notNull()
+        .references(() => match.id),
+    // The number of the match game in its match
+    number: integer('number').notNull(),
+    // Status of the match game (0=Locked, 1=Waiting, 2=Ready, 3=Running, 4=Completed, 5=Archived)
+    status: integer('status').notNull(),
+    // First opponent of the match game (embedded as JSONB)
+    opponent1: jsonb('opponent1').$type(),
+    // Second opponent of the match game (embedded as JSONB)
+    opponent2: jsonb('opponent2').$type(),
+});
+export const matchGameRelations = relations(matchGame, ({ one }) => ({
+    stage: one(stage, {
+        fields: [matchGame.stage_id],
+        references: [stage.id],
+    }),
+    match: one(match, {
+        fields: [matchGame.parent_id],
+        references: [match.id],
+    }),
+}));
+//# sourceMappingURL=match-game.js.map

package/dist/storage/drizzle/db/schema/match-game.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"match-game.js","sourceRoot":"","sources":["../../../../../src/storage/drizzle/db/schema/match-game.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AACpE,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAGhC,yBAAyB;AACzB,MAAM,CAAC,MAAM,SAAS,GAAG,OAAO,CAAC,YAAY,EAAE;IAC3C,EAAE,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC,UAAU,EAAE;IAC3B,0BAA0B;IAC1B,QAAQ,EAAE,IAAI,CAAC,UAAU,CAAC;SACrB,OAAO,EAAE;SACT,UAAU,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC;IAC/B,0BAA0B;IAC1B,SAAS,EAAE,IAAI,CAAC,WAAW,CAAC;SACvB,OAAO,EAAE;SACT,UAAU,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC;IAC/B,4CAA4C;IAC5C,MAAM,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC,OAAO,EAAE;IACnC,8FAA8F;IAC9F,MAAM,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC,OAAO,EAAE;IACnC,uDAAuD;IACvD,SAAS,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC,KAAK,EAA4B;IAC/D,wDAAwD;IACxD,SAAS,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC,KAAK,EAA4B;CAClE,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,kBAAkB,GAAG,SAAS,CAAC,SAAS,EAAE,CAAC,EAAE,GAAG,EAAE,EAAE,EAAE,CAAC,CAAC;IACjE,KAAK,EAAE,GAAG,CAAC,KAAK,EAAE;QACd,MAAM,EAAE,CAAC,SAAS,CAAC,QAAQ,CAAC;QAC5B,UAAU,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC;KACzB,CAAC;IACF,KAAK,EAAE,GAAG,CAAC,KAAK,EAAE;QACd,MAAM,EAAE,CAAC,SAAS,CAAC,SAAS,CAAC;QAC7B,UAAU,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC;KACzB,CAAC;CACL,CAAC,CAAC,CAAC"}

package/dist/storage/drizzle/db/schema/match.d.ts

@@ -0,0 +1,174 @@
+import type { ParticipantResult } from '../../../../model';
+export declare const match: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "match";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "match";
+            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;
+        }, {}, {}>;
+        stage_id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "stage_id";
+            tableName: "match";
+            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;
+        }, {}, {}>;
+        group_id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "group_id";
+            tableName: "match";
+            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;
+        }, {}, {}>;
+        round_id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "round_id";
+            tableName: "match";
+            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;
+        }, {}, {}>;
+        number: import("drizzle-orm/pg-core").PgColumn<{
+            name: "number";
+            tableName: "match";
+            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;
+        }, {}, {}>;
+        child_count: import("drizzle-orm/pg-core").PgColumn<{
+            name: "child_count";
+            tableName: "match";
+            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;
+        }, {}, {}>;
+        status: import("drizzle-orm/pg-core").PgColumn<{
+            name: "status";
+            tableName: "match";
+            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;
+        }, {}, {}>;
+        opponent1: import("drizzle-orm/pg-core").PgColumn<{
+            name: "opponent1";
+            tableName: "match";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: ParticipantResult | null;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: ParticipantResult | null;
+        }>;
+        opponent2: import("drizzle-orm/pg-core").PgColumn<{
+            name: "opponent2";
+            tableName: "match";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: ParticipantResult | null;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: ParticipantResult | null;
+        }>;
+    };
+    dialect: "pg";
+}>;
+export declare const matchRelations: import("drizzle-orm").Relations<"match", {
+    stage: import("drizzle-orm").One<"stage", true>;
+    group: import("drizzle-orm").One<"group", true>;
+    round: import("drizzle-orm").One<"round", true>;
+    games: import("drizzle-orm").Many<"match_game">;
+}>;
+export type Match = typeof match.$inferSelect;
+export type NewMatch = typeof match.$inferInsert;
+//# sourceMappingURL=match.d.ts.map

package/dist/storage/drizzle/db/schema/match.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"match.d.ts","sourceRoot":"","sources":["../../../../../src/storage/drizzle/db/schema/match.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAGjD,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwBhB,CAAC;AAEH,eAAO,MAAM,cAAc;;;;;EAcxB,CAAC;AAEJ,MAAM,MAAM,KAAK,GAAG,OAAO,KAAK,CAAC,YAAY,CAAC;AAC9C,MAAM,MAAM,QAAQ,GAAG,OAAO,KAAK,CAAC,YAAY,CAAC"}

package/dist/storage/drizzle/db/schema/match.js

@@ -0,0 +1,48 @@
+import { integer, jsonb, pgTable, text } from 'drizzle-orm/pg-core';
+import { relations } from 'drizzle-orm';
+import { stage } from './stage';
+import { group } from './group';
+import { round } from './round';
+import { matchGame } from './match-game';
+// A match in a round.
+export const match = pgTable('match', {
+    id: text('id').primaryKey(),
+    // ID of the parent stage.
+    stage_id: text('stage_id')
+        .notNull()
+        .references(() => stage.id),
+    // ID of the parent group.
+    group_id: text('group_id')
+        .notNull()
+        .references(() => group.id),
+    // ID of the parent round.
+    round_id: text('round_id')
+        .notNull()
+        .references(() => round.id),
+    // The number of the match in its round
+    number: integer('number').notNull(),
+    // The count of match games this match has.
+    child_count: integer('child_count').notNull(),
+    // Status of the match (0=Locked, 1=Waiting, 2=Ready, 3=Running, 4=Completed, 5=Archived)
+    status: integer('status').notNull(),
+    // First opponent of the match (embedded as JSONB)
+    opponent1: jsonb('opponent1').$type(),
+    // Second opponent of the match (embedded as JSONB)
+    opponent2: jsonb('opponent2').$type(),
+});
+export const matchRelations = relations(match, ({ one, many }) => ({
+    stage: one(stage, {
+        fields: [match.stage_id],
+        references: [stage.id],
+    }),
+    group: one(group, {
+        fields: [match.group_id],
+        references: [group.id],
+    }),
+    round: one(round, {
+        fields: [match.round_id],
+        references: [round.id],
+    }),
+    games: many(matchGame),
+}));
+//# sourceMappingURL=match.js.map

package/dist/storage/drizzle/db/schema/match.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"match.js","sourceRoot":"","sources":["../../../../../src/storage/drizzle/db/schema/match.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AACpE,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAGzC,sBAAsB;AACtB,MAAM,CAAC,MAAM,KAAK,GAAG,OAAO,CAAC,OAAO,EAAE;IAClC,EAAE,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC,UAAU,EAAE;IAC3B,0BAA0B;IAC1B,QAAQ,EAAE,IAAI,CAAC,UAAU,CAAC;SACrB,OAAO,EAAE;SACT,UAAU,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC;IAC/B,0BAA0B;IAC1B,QAAQ,EAAE,IAAI,CAAC,UAAU,CAAC;SACrB,OAAO,EAAE;SACT,UAAU,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC;IAC/B,0BAA0B;IAC1B,QAAQ,EAAE,IAAI,CAAC,UAAU,CAAC;SACrB,OAAO,EAAE;SACT,UAAU,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC;IAC/B,uCAAuC;IACvC,MAAM,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC,OAAO,EAAE;IACnC,2CAA2C;IAC3C,WAAW,EAAE,OAAO,CAAC,aAAa,CAAC,CAAC,OAAO,EAAE;IAC7C,yFAAyF;IACzF,MAAM,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC,OAAO,EAAE;IACnC,kDAAkD;IAClD,SAAS,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC,KAAK,EAA4B;IAC/D,mDAAmD;IACnD,SAAS,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC,KAAK,EAA4B;CAClE,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,cAAc,GAAG,SAAS,CAAC,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,CAAC;IAC/D,KAAK,EAAE,GAAG,CAAC,KAAK,EAAE;QACd,MAAM,EAAE,CAAC,KAAK,CAAC,QAAQ,CAAC;QACxB,UAAU,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC;KACzB,CAAC;IACF,KAAK,EAAE,GAAG,CAAC,KAAK,EAAE;QACd,MAAM,EAAE,CAAC,KAAK,CAAC,QAAQ,CAAC;QACxB,UAAU,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC;KACzB,CAAC;IACF,KAAK,EAAE,GAAG,CAAC,KAAK,EAAE;QACd,MAAM,EAAE,CAAC,KAAK,CAAC,QAAQ,CAAC;QACxB,UAAU,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC;KACzB,CAAC;IACF,KAAK,EAAE,IAAI,CAAC,SAAS,CAAC;CACzB,CAAC,CAAC,CAAC"}