brackets-drizzle-db 2.1.0

package/README.md

@@ -0,0 +1,136 @@
+# brackets-drizzle-db
+
+This implementation of the [`CrudInterface`](https://drarig29.github.io/brackets-docs/reference/manager/interfaces/CrudInterface.html)
+uses [Drizzle ORM](https://orm.drizzle.team/) to store the data in a PostgreSQL database.
+
+## Installation
+
+```bash
+pnpm add brackets-drizzle-db
+```
+
+## Usage
+
+### Basic Setup
+
+```typescript
+import { SqlDatabase, createDatabase } from 'brackets-drizzle-db';
+import { BracketsManager } from 'brackets-manager';
+
+// Create the Drizzle database instance
+const db = createDatabase(process.env.DATABASE_URL!);
+
+const storage = new SqlDatabase(db);
+const manager = new BracketsManager(storage);
+```
+
+### Integrating with Your Drizzle Schema
+
+If you already have a Drizzle project, you can import the schema definitions and include them in your own schema:
+
+```typescript
+// In your drizzle schema file
+import * as bracketsSchema from 'brackets-drizzle-db';
+
+// Export alongside your own schema
+export * from './your-tables';
+export { bracketsSchema };
+```
+
+Then in your drizzle config, make sure to include the brackets schema:
+
+```typescript
+// drizzle.config.ts
+import { defineConfig } from 'drizzle-kit';
+
+export default defineConfig({
+    schema: ['./src/db/schema.ts', './node_modules/brackets-drizzle-db/dist/db/schema/index.js'],
+    out: './drizzle',
+    dialect: 'postgresql',
+    dbCredentials: {
+        url: process.env.DATABASE_URL!,
+    },
+});
+```
+
+### Using with an Existing Drizzle Instance
+
+If you already have a Drizzle database instance:
+
+```typescript
+import { SqlDatabase } from 'brackets-drizzle-db';
+import { BracketsManager } from 'brackets-manager';
+import { db } from './your-db-setup';
+
+const storage = new SqlDatabase(db);
+const manager = new BracketsManager(storage);
+```
+
+### Example with Custom Match Data
+
+```typescript
+import { SqlDatabase, createDatabase } from 'brackets-drizzle-db';
+import { BracketsManager } from 'brackets-manager';
+import type { Match } from 'brackets-model';
+
+type MatchWithWeather = Match & {
+  // The schema defines a JSON column named `extra` in the `Match` and `MatchGame` tables.
+  // Anything you put in the `extra` object will be stored in that column.
+  extra: {
+    weather: 'sunny' | 'rainy' | 'cloudy' | 'snowy';
+  };
+};
+
+const db = createDatabase(process.env.DATABASE_URL!);
+const storage = new SqlDatabase(db);
+const manager = new BracketsManager(storage);
+
+const stage = await manager.create.stage({
+  tournamentId: 1,
+  name: 'Example',
+  type: 'single_elimination',
+  seeding: [
+    { name: 'Team 1' },
+    { name: 'Team 2' },
+    { name: 'Team 3' },
+    { name: 'Team 4' },
+  ],
+});
+
+const currentMatches = await manager.get.currentMatches(stage.id);
+
+await manager.update.match<MatchWithWeather>({
+  id: currentMatches[0].id,
+  opponent1: { score: 6, result: 'win' },
+  opponent2: { score: 3, result: 'loss' },
+  extra: {
+    weather: 'sunny',
+  },
+});
+```
+
+## Schema
+
+The package exports all Drizzle schema definitions for use in your project:
+
+```typescript
+import {
+  // Tables
+  participant,
+  stage,
+  stageSettings,
+  group,
+  round,
+  match,
+  matchGame,
+  participantMatchResult,
+  participantMatchGameResult,
+  // Enums
+  stageTypeEnum,
+  grandFinalTypeEnum,
+  roundRobinModeEnum,
+  seedOrderingEnum,
+  matchResultEnum,
+  matchStatusEnum,
+} from 'brackets-drizzle-db';
+```

package/dist/db/index.d.ts

@@ -0,0 +1,7 @@
+import postgres from 'postgres';
+import * as schema from './schema';
+export type DrizzleDatabase = ReturnType<typeof createDatabase>;
+export declare function createDatabase(connectionString: string): import("drizzle-orm/postgres-js").PostgresJsDatabase<typeof schema> & {
+    $client: postgres.Sql<{}>;
+};
+export { schema };

package/dist/db/index.js

@@ -0,0 +1,48 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schema = void 0;
+exports.createDatabase = createDatabase;
+const postgres_js_1 = require("drizzle-orm/postgres-js");
+const postgres_1 = __importDefault(require("postgres"));
+const schema = __importStar(require("./schema"));
+exports.schema = schema;
+function createDatabase(connectionString) {
+    const client = (0, postgres_1.default)(connectionString);
+    return (0, postgres_js_1.drizzle)(client, { schema });
+}

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

@@ -0,0 +1,12 @@
+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"]>;
+export declare const matchStatusEnum: import("drizzle-orm/pg-core").PgEnum<["LOCKED", "WAITING", "READY", "RUNNING", "COMPLETED", "ARCHIVED"]>;
+export type StageType = (typeof stageTypeEnum.enumValues)[number];
+export type GrandFinalType = (typeof grandFinalTypeEnum.enumValues)[number];
+export type RoundRobinMode = (typeof roundRobinModeEnum.enumValues)[number];
+export type SeedOrdering = (typeof seedOrderingEnum.enumValues)[number];
+export type MatchResult = (typeof matchResultEnum.enumValues)[number];
+export type MatchStatus = (typeof matchStatusEnum.enumValues)[number];

package/dist/db/schema/enums.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchStatusEnum = exports.matchResultEnum = exports.seedOrderingEnum = exports.roundRobinModeEnum = exports.grandFinalTypeEnum = exports.stageTypeEnum = void 0;
+const pg_core_1 = require("drizzle-orm/pg-core");
+// The only supported types of stage.
+exports.stageTypeEnum = (0, pg_core_1.pgEnum)('StageType', [
+    'ROUND_ROBIN',
+    'SINGLE_ELIMINATION',
+    'DOUBLE_ELIMINATION',
+]);
+// The possible types for a double elimination stage's grand final.
+exports.grandFinalTypeEnum = (0, pg_core_1.pgEnum)('GrandFinalType', [
+    'NONE',
+    'SIMPLE',
+    'DOUBLE',
+]);
+// The possible modes for a round-robin stage.
+exports.roundRobinModeEnum = (0, pg_core_1.pgEnum)('RoundRobinMode', ['SIMPLE', 'DOUBLE']);
+// Used to order seeds.
+exports.seedOrderingEnum = (0, pg_core_1.pgEnum)('SeedOrdering', [
+    '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.
+exports.matchResultEnum = (0, pg_core_1.pgEnum)('MatchResult', ['WIN', 'DRAW', 'LOSS']);
+// The possible status for a match.
+exports.matchStatusEnum = (0, pg_core_1.pgEnum)('MatchStatus', [
+    'LOCKED',
+    'WAITING',
+    'READY',
+    'RUNNING',
+    'COMPLETED',
+    'ARCHIVED',
+]);

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

@@ -0,0 +1,65 @@
+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;
+        }, {}, {}>;
+        stageId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "stageId";
+            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;

package/dist/db/schema/group.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.groupRelations = exports.group = void 0;
+const pg_core_1 = require("drizzle-orm/pg-core");
+const drizzle_orm_1 = require("drizzle-orm");
+const stage_1 = require("./stage");
+const round_1 = require("./round");
+const match_1 = require("./match");
+// A group of a stage.
+exports.group = (0, pg_core_1.pgTable)('Group', {
+    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),
+    // The number of the group in its stage
+    number: (0, pg_core_1.integer)('number').notNull(),
+});
+exports.groupRelations = (0, drizzle_orm_1.relations)(exports.group, ({ one, many }) => ({
+    stage: one(stage_1.stage, {
+        fields: [exports.group.stageId],
+        references: [stage_1.stage.id],
+    }),
+    rounds: many(round_1.round),
+    matches: many(match_1.match),
+}));

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

@@ -0,0 +1,8 @@
+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';

package/dist/db/schema/index.js

@@ -0,0 +1,26 @@
+"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 });
+// Enums
+__exportStar(require("./enums"), exports);
+// Tables and relations
+__exportStar(require("./tournament"), exports);
+__exportStar(require("./participant"), exports);
+__exportStar(require("./stage"), exports);
+__exportStar(require("./group"), exports);
+__exportStar(require("./round"), exports);
+__exportStar(require("./match"), exports);
+__exportStar(require("./match-game"), exports);

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

@@ -0,0 +1,267 @@
+export declare const matchGame: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "MatchGame";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "MatchGame";
+            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;
+        }, {}, {}>;
+        status: import("drizzle-orm/pg-core").PgColumn<{
+            name: "status";
+            tableName: "MatchGame";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "LOCKED" | "WAITING" | "READY" | "RUNNING" | "COMPLETED" | "ARCHIVED";
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["LOCKED", "WAITING", "READY", "RUNNING", "COMPLETED", "ARCHIVED"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        extra: import("drizzle-orm/pg-core").PgColumn<{
+            name: "extra";
+            tableName: "MatchGame";
+            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;
+        }, {}, {}>;
+        stageId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "stageId";
+            tableName: "MatchGame";
+            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;
+        }, {}, {}>;
+        matchId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "matchId";
+            tableName: "MatchGame";
+            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: "MatchGame";
+            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 matchGameRelations: import("drizzle-orm").Relations<"MatchGame", {
+    stage: import("drizzle-orm").One<"Stage", true>;
+    match: import("drizzle-orm").One<"Match", true>;
+    opponent1Result: import("drizzle-orm").One<"ParticipantMatchGameResult", true>;
+    opponent2Result: import("drizzle-orm").One<"ParticipantMatchGameResult", true>;
+}>;
+export declare const participantMatchGameResult: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "ParticipantMatchGameResult";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "ParticipantMatchGameResult";
+            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;
+        }, {}, {}>;
+        participantId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "participantId";
+            tableName: "ParticipantMatchGameResult";
+            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;
+        }, {}, {}>;
+        position: import("drizzle-orm/pg-core").PgColumn<{
+            name: "position";
+            tableName: "ParticipantMatchGameResult";
+            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;
+        }, {}, {}>;
+        forfeit: import("drizzle-orm/pg-core").PgColumn<{
+            name: "forfeit";
+            tableName: "ParticipantMatchGameResult";
+            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;
+        }, {}, {}>;
+        score: import("drizzle-orm/pg-core").PgColumn<{
+            name: "score";
+            tableName: "ParticipantMatchGameResult";
+            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;
+        }, {}, {}>;
+        result: import("drizzle-orm/pg-core").PgColumn<{
+            name: "result";
+            tableName: "ParticipantMatchGameResult";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "WIN" | "DRAW" | "LOSS";
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["WIN", "DRAW", "LOSS"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        opponent1MatchGameId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "opponent1MatchGameId";
+            tableName: "ParticipantMatchGameResult";
+            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;
+        }, {}, {}>;
+        opponent2MatchGameId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "opponent2MatchGameId";
+            tableName: "ParticipantMatchGameResult";
+            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;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export declare const participantMatchGameResultRelations: import("drizzle-orm").Relations<"ParticipantMatchGameResult", {
+    participant: import("drizzle-orm").One<"Participant", false>;
+    opponent1MatchGame: import("drizzle-orm").One<"MatchGame", false>;
+    opponent2MatchGame: import("drizzle-orm").One<"MatchGame", false>;
+}>;
+export type MatchGame = typeof matchGame.$inferSelect;
+export type NewMatchGame = typeof matchGame.$inferInsert;
+export type ParticipantMatchGameResult = typeof participantMatchGameResult.$inferSelect;
+export type NewParticipantMatchGameResult = typeof participantMatchGameResult.$inferInsert;