@weekendgoals/weekendgoals-common 1.609.6797680924

package/dist/db/connect.d.ts

@@ -0,0 +1,3 @@
+import * as mongoose from "mongoose";
+export declare function connectToMongoDb(): Promise<typeof mongoose>;
+//# sourceMappingURL=connect.d.ts.map

package/dist/db/connect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connect.d.ts","sourceRoot":"","sources":["../../src/db/connect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,QAAQ,MAAM,UAAU,CAAC;AAErC,wBAAsB,gBAAgB,6BAcrC"}

package/dist/db/connect.js

@@ -0,0 +1,28 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectToMongoDb = void 0;
+const mongoose = require("mongoose");
+function connectToMongoDb() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const dbUrl = process.env.DB_URL;
+        const dbUser = process.env.DB_USER;
+        const dbPassword = process.env.DB_PASSWORD;
+        mongoose.set("strictQuery", false);
+        const result = yield mongoose.connect(dbUrl, {
+            user: dbUser,
+            pass: dbPassword,
+        });
+        return result;
+    });
+}
+exports.connectToMongoDb = connectToMongoDb;
+//# sourceMappingURL=connect.js.map

package/dist/db/connect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"connect.js","sourceRoot":"","sources":["../../src/db/connect.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,qCAAqC;AAErC,SAAsB,gBAAgB;;QACpC,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC;QAEjC,MAAM,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC;QACnC,MAAM,UAAU,GAAG,OAAO,CAAC,GAAG,CAAC,WAAW,CAAC;QAE3C,QAAQ,CAAC,GAAG,CAAC,aAAa,EAAE,KAAK,CAAC,CAAC;QAEnC,MAAM,MAAM,GAAG,MAAM,QAAQ,CAAC,OAAO,CAAC,KAAK,EAAE;YAC3C,IAAI,EAAE,MAAM;YACZ,IAAI,EAAE,UAAU;SACjB,CAAC,CAAC;QAEH,OAAO,MAAM,CAAC;IAChB,CAAC;CAAA;AAdD,4CAcC"}

package/dist/models/attractions/index.d.ts

@@ -0,0 +1,194 @@
+import * as mongoose from "mongoose";
+export declare const AttractionSchema: mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: true;
+}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name?: string;
+    type?: number;
+    venueId?: string;
+    description?: string;
+    hash?: string;
+    location?: {
+        enum: unknown[];
+        type?: string;
+        required?: unknown;
+    };
+    address?: {
+        street?: string;
+        area?: string;
+        city?: string;
+        country?: string;
+    };
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name?: string;
+    type?: number;
+    venueId?: string;
+    description?: string;
+    hash?: string;
+    location?: {
+        enum: unknown[];
+        type?: string;
+        required?: unknown;
+    };
+    address?: {
+        street?: string;
+        area?: string;
+        city?: string;
+        country?: string;
+    };
+}>> & mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name?: string;
+    type?: number;
+    venueId?: string;
+    description?: string;
+    hash?: string;
+    location?: {
+        enum: unknown[];
+        type?: string;
+        required?: unknown;
+    };
+    address?: {
+        street?: string;
+        area?: string;
+        city?: string;
+        country?: string;
+    };
+}> & {
+    _id: mongoose.Types.ObjectId;
+}>;
+export declare const AttractionModel: mongoose.Model<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name?: string;
+    type?: number;
+    venueId?: string;
+    description?: string;
+    hash?: string;
+    location?: {
+        enum: unknown[];
+        type?: string;
+        required?: unknown;
+    };
+    address?: {
+        street?: string;
+        area?: string;
+        city?: string;
+        country?: string;
+    };
+}, {}, {}, {}, mongoose.Document<unknown, {}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name?: string;
+    type?: number;
+    venueId?: string;
+    description?: string;
+    hash?: string;
+    location?: {
+        enum: unknown[];
+        type?: string;
+        required?: unknown;
+    };
+    address?: {
+        street?: string;
+        area?: string;
+        city?: string;
+        country?: string;
+    };
+}> & {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name?: string;
+    type?: number;
+    venueId?: string;
+    description?: string;
+    hash?: string;
+    location?: {
+        enum: unknown[];
+        type?: string;
+        required?: unknown;
+    };
+    address?: {
+        street?: string;
+        area?: string;
+        city?: string;
+        country?: string;
+    };
+} & {
+    _id: mongoose.Types.ObjectId;
+}, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: true;
+}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name?: string;
+    type?: number;
+    venueId?: string;
+    description?: string;
+    hash?: string;
+    location?: {
+        enum: unknown[];
+        type?: string;
+        required?: unknown;
+    };
+    address?: {
+        street?: string;
+        area?: string;
+        city?: string;
+        country?: string;
+    };
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name?: string;
+    type?: number;
+    venueId?: string;
+    description?: string;
+    hash?: string;
+    location?: {
+        enum: unknown[];
+        type?: string;
+        required?: unknown;
+    };
+    address?: {
+        street?: string;
+        area?: string;
+        city?: string;
+        country?: string;
+    };
+}>> & mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name?: string;
+    type?: number;
+    venueId?: string;
+    description?: string;
+    hash?: string;
+    location?: {
+        enum: unknown[];
+        type?: string;
+        required?: unknown;
+    };
+    address?: {
+        street?: string;
+        area?: string;
+        city?: string;
+        country?: string;
+    };
+}> & {
+    _id: mongoose.Types.ObjectId;
+}>>;
+//# sourceMappingURL=index.d.ts.map

package/dist/models/attractions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/models/attractions/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,QAAQ,MAAM,UAAU,CAAC;AAErC,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0B5B,CAAC;AAEF,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAI3B,CAAC"}

package/dist/models/attractions/index.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AttractionModel = exports.AttractionSchema = void 0;
+const mongoose = require("mongoose");
+exports.AttractionSchema = new mongoose.Schema({
+    name: String,
+    hash: { type: String, unique: true },
+    location: {
+        type: {
+            type: String,
+            enum: ["Point"],
+            required: true,
+        },
+        coordinates: {
+            type: [Number],
+            required: true,
+        },
+    },
+    address: {
+        street: String,
+        area: String,
+        city: String,
+        country: String,
+    },
+    type: Number,
+    venueId: String,
+    description: String,
+}, { timestamps: true });
+exports.AttractionModel = mongoose.model("Attraction", exports.AttractionSchema, "Attractions");
+//# sourceMappingURL=index.js.map

package/dist/models/attractions/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/models/attractions/index.ts"],"names":[],"mappings":";;;AAAA,qCAAqC;AAExB,QAAA,gBAAgB,GAAG,IAAI,QAAQ,CAAC,MAAM,CACjD;IACE,IAAI,EAAE,MAAM;IACZ,IAAI,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE;IACpC,QAAQ,EAAE;QACR,IAAI,EAAE;YACJ,IAAI,EAAE,MAAM;YACZ,IAAI,EAAE,CAAC,OAAO,CAAC;YACf,QAAQ,EAAE,IAAI;SACf;QACD,WAAW,EAAE;YACX,IAAI,EAAE,CAAC,MAAM,CAAC;YACd,QAAQ,EAAE,IAAI;SACf;KACF;IACD,OAAO,EAAE;QACP,MAAM,EAAE,MAAM;QACd,IAAI,EAAE,MAAM;QACZ,IAAI,EAAE,MAAM;QACZ,OAAO,EAAE,MAAM;KAChB;IACD,IAAI,EAAE,MAAM;IACZ,OAAO,EAAE,MAAM;IACf,WAAW,EAAE,MAAM;CACpB,EACD,EAAE,UAAU,EAAE,IAAI,EAAE,CACrB,CAAC;AAEW,QAAA,eAAe,GAAG,QAAQ,CAAC,KAAK,CAC3C,YAAY,EACZ,wBAAgB,EAChB,aAAa,CACd,CAAC"}

package/dist/models/leagues/index.d.ts

@@ -0,0 +1,86 @@
+import * as mongoose from "mongoose";
+export declare const LeagueSchema: mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: true;
+}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name?: string;
+    country?: string;
+    rank?: number;
+    soccerwaySlug?: string;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name?: string;
+    country?: string;
+    rank?: number;
+    soccerwaySlug?: string;
+}>> & mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name?: string;
+    country?: string;
+    rank?: number;
+    soccerwaySlug?: string;
+}> & {
+    _id: mongoose.Types.ObjectId;
+}>;
+export declare const LeagueModel: mongoose.Model<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name?: string;
+    country?: string;
+    rank?: number;
+    soccerwaySlug?: string;
+}, {}, {}, {}, mongoose.Document<unknown, {}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name?: string;
+    country?: string;
+    rank?: number;
+    soccerwaySlug?: string;
+}> & {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name?: string;
+    country?: string;
+    rank?: number;
+    soccerwaySlug?: string;
+} & {
+    _id: mongoose.Types.ObjectId;
+}, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: true;
+}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name?: string;
+    country?: string;
+    rank?: number;
+    soccerwaySlug?: string;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name?: string;
+    country?: string;
+    rank?: number;
+    soccerwaySlug?: string;
+}>> & mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name?: string;
+    country?: string;
+    rank?: number;
+    soccerwaySlug?: string;
+}> & {
+    _id: mongoose.Types.ObjectId;
+}>>;
+//# sourceMappingURL=index.d.ts.map

package/dist/models/leagues/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/models/leagues/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,QAAQ,MAAM,UAAU,CAAC;AACrC,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQyB,CAAC;AAEnD,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAoD,CAAC"}

package/dist/models/leagues/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LeagueModel = exports.LeagueSchema = void 0;
+const mongoose = require("mongoose");
+exports.LeagueSchema = new mongoose.Schema({
+    country: String,
+    name: String,
+    rank: Number,
+    soccerwaySlug: String,
+}, { timestamps: true }).index({ country: 1, name: 1 }, { unique: true });
+exports.LeagueModel = mongoose.model("League", exports.LeagueSchema, "Leagues");
+//# sourceMappingURL=index.js.map

package/dist/models/leagues/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/models/leagues/index.ts"],"names":[],"mappings":";;;AAAA,qCAAqC;AACxB,QAAA,YAAY,GAAG,IAAI,QAAQ,CAAC,MAAM,CAC7C;IACE,OAAO,EAAE,MAAM;IACf,IAAI,EAAE,MAAM;IACZ,IAAI,EAAE,MAAM;IACZ,aAAa,EAAE,MAAM;CACtB,EACD,EAAE,UAAU,EAAE,IAAI,EAAE,CACrB,CAAC,KAAK,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC;AAEtC,QAAA,WAAW,GAAG,QAAQ,CAAC,KAAK,CAAC,QAAQ,EAAE,oBAAY,EAAE,SAAS,CAAC,CAAC"}

package/dist/models/matches/index.d.ts

@@ -0,0 +1,187 @@
+import * as mongoose from "mongoose";
+export declare const MatchSchema: mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: true;
+    typeKey: "$type";
+}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    venueId?: string;
+    hash?: string;
+    location?: {
+        type: "Point";
+        coordinates: number[];
+    };
+    competitionId?: string;
+    competitionName?: string;
+    homeTeamId?: string;
+    homeTeamHash?: string;
+    awayTeamId?: string;
+    awayTeamHash?: string;
+    kickoff?: Date;
+    status?: string;
+    localTimeKickoff?: Date;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    venueId?: string;
+    hash?: string;
+    location?: {
+        type: "Point";
+        coordinates: number[];
+    };
+    competitionId?: string;
+    competitionName?: string;
+    homeTeamId?: string;
+    homeTeamHash?: string;
+    awayTeamId?: string;
+    awayTeamHash?: string;
+    kickoff?: Date;
+    status?: string;
+    localTimeKickoff?: Date;
+}>> & mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    venueId?: string;
+    hash?: string;
+    location?: {
+        type: "Point";
+        coordinates: number[];
+    };
+    competitionId?: string;
+    competitionName?: string;
+    homeTeamId?: string;
+    homeTeamHash?: string;
+    awayTeamId?: string;
+    awayTeamHash?: string;
+    kickoff?: Date;
+    status?: string;
+    localTimeKickoff?: Date;
+}> & {
+    _id: mongoose.Types.ObjectId;
+}>;
+export declare const MatchModel: mongoose.Model<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    venueId?: string;
+    hash?: string;
+    location?: {
+        type: "Point";
+        coordinates: number[];
+    };
+    competitionId?: string;
+    competitionName?: string;
+    homeTeamId?: string;
+    homeTeamHash?: string;
+    awayTeamId?: string;
+    awayTeamHash?: string;
+    kickoff?: Date;
+    status?: string;
+    localTimeKickoff?: Date;
+}, {}, {}, {}, mongoose.Document<unknown, {}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    venueId?: string;
+    hash?: string;
+    location?: {
+        type: "Point";
+        coordinates: number[];
+    };
+    competitionId?: string;
+    competitionName?: string;
+    homeTeamId?: string;
+    homeTeamHash?: string;
+    awayTeamId?: string;
+    awayTeamHash?: string;
+    kickoff?: Date;
+    status?: string;
+    localTimeKickoff?: Date;
+}> & {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    venueId?: string;
+    hash?: string;
+    location?: {
+        type: "Point";
+        coordinates: number[];
+    };
+    competitionId?: string;
+    competitionName?: string;
+    homeTeamId?: string;
+    homeTeamHash?: string;
+    awayTeamId?: string;
+    awayTeamHash?: string;
+    kickoff?: Date;
+    status?: string;
+    localTimeKickoff?: Date;
+} & {
+    _id: mongoose.Types.ObjectId;
+}, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: true;
+    typeKey: "$type";
+}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    venueId?: string;
+    hash?: string;
+    location?: {
+        type: "Point";
+        coordinates: number[];
+    };
+    competitionId?: string;
+    competitionName?: string;
+    homeTeamId?: string;
+    homeTeamHash?: string;
+    awayTeamId?: string;
+    awayTeamHash?: string;
+    kickoff?: Date;
+    status?: string;
+    localTimeKickoff?: Date;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    venueId?: string;
+    hash?: string;
+    location?: {
+        type: "Point";
+        coordinates: number[];
+    };
+    competitionId?: string;
+    competitionName?: string;
+    homeTeamId?: string;
+    homeTeamHash?: string;
+    awayTeamId?: string;
+    awayTeamHash?: string;
+    kickoff?: Date;
+    status?: string;
+    localTimeKickoff?: Date;
+}>> & mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    venueId?: string;
+    hash?: string;
+    location?: {
+        type: "Point";
+        coordinates: number[];
+    };
+    competitionId?: string;
+    competitionName?: string;
+    homeTeamId?: string;
+    homeTeamHash?: string;
+    awayTeamId?: string;
+    awayTeamHash?: string;
+    kickoff?: Date;
+    status?: string;
+    localTimeKickoff?: Date;
+}> & {
+    _id: mongoose.Types.ObjectId;
+}>>;
+//# sourceMappingURL=index.d.ts.map

package/dist/models/matches/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/models/matches/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,QAAQ,MAAM,UAAU,CAAC;AAErC,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8BvB,CAAC;AAEF,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAkD,CAAC"}

package/dist/models/matches/index.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MatchModel = exports.MatchSchema = void 0;
+const mongoose = require("mongoose");
+exports.MatchSchema = new mongoose.Schema({
+    competitionId: String,
+    competitionName: String,
+    homeTeamId: String,
+    homeTeamHash: String,
+    awayTeamId: String,
+    awayTeamHash: String,
+    venueId: String,
+    location: {
+        $type: {
+            type: {
+                $type: String,
+                enum: ["Point"],
+                required: true,
+            },
+            coordinates: {
+                $type: [Number],
+                required: true,
+            },
+        },
+        required: false,
+        _id: false,
+    },
+    hash: { $type: String, unique: true },
+    kickoff: Date,
+    status: String,
+    localTimeKickoff: Date,
+}, { timestamps: true, typeKey: "$type" });
+exports.MatchModel = mongoose.model("Match", exports.MatchSchema, "Matches");
+//# sourceMappingURL=index.js.map

package/dist/models/matches/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/models/matches/index.ts"],"names":[],"mappings":";;;AAAA,qCAAqC;AAExB,QAAA,WAAW,GAAG,IAAI,QAAQ,CAAC,MAAM,CAC5C;IACE,aAAa,EAAE,MAAM;IACrB,eAAe,EAAE,MAAM;IACvB,UAAU,EAAE,MAAM;IAClB,YAAY,EAAE,MAAM;IACpB,UAAU,EAAE,MAAM;IAClB,YAAY,EAAE,MAAM;IACpB,OAAO,EAAE,MAAM;IACf,QAAQ,EAAE;QACR,KAAK,EAAE;YACL,IAAI,EAAE;gBACJ,KAAK,EAAE,MAAM;gBACb,IAAI,EAAE,CAAC,OAAO,CAAC;gBACf,QAAQ,EAAE,IAAI;aACf;YACD,WAAW,EAAE;gBACX,KAAK,EAAE,CAAC,MAAM,CAAC;gBACf,QAAQ,EAAE,IAAI;aACf;SACF;QACD,QAAQ,EAAE,KAAK;QACf,GAAG,EAAE,KAAK;KACX;IACD,IAAI,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE;IACrC,OAAO,EAAE,IAAI;IACb,MAAM,EAAE,MAAM;IACd,gBAAgB,EAAE,IAAI;CACvB,EACD,EAAE,UAAU,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,CACvC,CAAC;AAEW,QAAA,UAAU,GAAG,QAAQ,CAAC,KAAK,CAAC,OAAO,EAAE,mBAAW,EAAE,SAAS,CAAC,CAAC"}

package/dist/models/teams/index.d.ts

@@ -0,0 +1,140 @@
+import * as mongoose from "mongoose";
+export declare const TeamsSchema: mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: true;
+}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name?: string;
+    venueId?: string;
+    hash?: string;
+    soccerwaySlug?: string;
+    leagueId?: string;
+    metadata?: {
+        instagramUrl?: string;
+        websiteUrl?: string;
+        ticketsUrl?: string;
+    };
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name?: string;
+    venueId?: string;
+    hash?: string;
+    soccerwaySlug?: string;
+    leagueId?: string;
+    metadata?: {
+        instagramUrl?: string;
+        websiteUrl?: string;
+        ticketsUrl?: string;
+    };
+}>> & mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name?: string;
+    venueId?: string;
+    hash?: string;
+    soccerwaySlug?: string;
+    leagueId?: string;
+    metadata?: {
+        instagramUrl?: string;
+        websiteUrl?: string;
+        ticketsUrl?: string;
+    };
+}> & {
+    _id: mongoose.Types.ObjectId;
+}>;
+export declare const TeamModel: mongoose.Model<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name?: string;
+    venueId?: string;
+    hash?: string;
+    soccerwaySlug?: string;
+    leagueId?: string;
+    metadata?: {
+        instagramUrl?: string;
+        websiteUrl?: string;
+        ticketsUrl?: string;
+    };
+}, {}, {}, {}, mongoose.Document<unknown, {}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name?: string;
+    venueId?: string;
+    hash?: string;
+    soccerwaySlug?: string;
+    leagueId?: string;
+    metadata?: {
+        instagramUrl?: string;
+        websiteUrl?: string;
+        ticketsUrl?: string;
+    };
+}> & {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name?: string;
+    venueId?: string;
+    hash?: string;
+    soccerwaySlug?: string;
+    leagueId?: string;
+    metadata?: {
+        instagramUrl?: string;
+        websiteUrl?: string;
+        ticketsUrl?: string;
+    };
+} & {
+    _id: mongoose.Types.ObjectId;
+}, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: true;
+}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name?: string;
+    venueId?: string;
+    hash?: string;
+    soccerwaySlug?: string;
+    leagueId?: string;
+    metadata?: {
+        instagramUrl?: string;
+        websiteUrl?: string;
+        ticketsUrl?: string;
+    };
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name?: string;
+    venueId?: string;
+    hash?: string;
+    soccerwaySlug?: string;
+    leagueId?: string;
+    metadata?: {
+        instagramUrl?: string;
+        websiteUrl?: string;
+        ticketsUrl?: string;
+    };
+}>> & mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name?: string;
+    venueId?: string;
+    hash?: string;
+    soccerwaySlug?: string;
+    leagueId?: string;
+    metadata?: {
+        instagramUrl?: string;
+        websiteUrl?: string;
+        ticketsUrl?: string;
+    };
+}> & {
+    _id: mongoose.Types.ObjectId;
+}>>;
+//# sourceMappingURL=index.d.ts.map

package/dist/models/teams/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/models/teams/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,QAAQ,MAAM,UAAU,CAAC;AACrC,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAcvB,CAAC;AAEF,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAA+C,CAAC"}

package/dist/models/teams/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TeamModel = exports.TeamsSchema = void 0;
+const mongoose = require("mongoose");
+exports.TeamsSchema = new mongoose.Schema({
+    name: String,
+    leagueId: String,
+    venueId: String,
+    hash: { type: String, unique: true },
+    metadata: {
+        instagramUrl: String,
+        websiteUrl: String,
+        ticketsUrl: String,
+    },
+    soccerwaySlug: String,
+}, { timestamps: true });
+exports.TeamModel = mongoose.model("Team", exports.TeamsSchema, "Teams");
+//# sourceMappingURL=index.js.map

package/dist/models/teams/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/models/teams/index.ts"],"names":[],"mappings":";;;AAAA,qCAAqC;AACxB,QAAA,WAAW,GAAG,IAAI,QAAQ,CAAC,MAAM,CAC5C;IACE,IAAI,EAAE,MAAM;IACZ,QAAQ,EAAE,MAAM;IAChB,OAAO,EAAE,MAAM;IACf,IAAI,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE;IACpC,QAAQ,EAAE;QACR,YAAY,EAAE,MAAM;QACpB,UAAU,EAAE,MAAM;QAClB,UAAU,EAAE,MAAM;KACnB;IACD,aAAa,EAAE,MAAM;CACtB,EACD,EAAE,UAAU,EAAE,IAAI,EAAE,CACrB,CAAC;AAEW,QAAA,SAAS,GAAG,QAAQ,CAAC,KAAK,CAAC,MAAM,EAAE,mBAAW,EAAE,OAAO,CAAC,CAAC"}

package/dist/models/users/index.d.ts

@@ -0,0 +1,95 @@
+import * as mongoose from "mongoose";
+export declare const UserSchema: mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: true;
+}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    email?: string;
+    lastLogin?: Date;
+    passwordHash?: string;
+    firstName?: string;
+    lastName?: string;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    email?: string;
+    lastLogin?: Date;
+    passwordHash?: string;
+    firstName?: string;
+    lastName?: string;
+}>> & mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    email?: string;
+    lastLogin?: Date;
+    passwordHash?: string;
+    firstName?: string;
+    lastName?: string;
+}> & {
+    _id: mongoose.Types.ObjectId;
+}>;
+export declare const UserModel: mongoose.Model<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    email?: string;
+    lastLogin?: Date;
+    passwordHash?: string;
+    firstName?: string;
+    lastName?: string;
+}, {}, {}, {}, mongoose.Document<unknown, {}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    email?: string;
+    lastLogin?: Date;
+    passwordHash?: string;
+    firstName?: string;
+    lastName?: string;
+}> & {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    email?: string;
+    lastLogin?: Date;
+    passwordHash?: string;
+    firstName?: string;
+    lastName?: string;
+} & {
+    _id: mongoose.Types.ObjectId;
+}, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: true;
+}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    email?: string;
+    lastLogin?: Date;
+    passwordHash?: string;
+    firstName?: string;
+    lastName?: string;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    email?: string;
+    lastLogin?: Date;
+    passwordHash?: string;
+    firstName?: string;
+    lastName?: string;
+}>> & mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    email?: string;
+    lastLogin?: Date;
+    passwordHash?: string;
+    firstName?: string;
+    lastName?: string;
+}> & {
+    _id: mongoose.Types.ObjectId;
+}>>;
+//# sourceMappingURL=index.d.ts.map

package/dist/models/users/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/models/users/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,QAAQ,MAAM,UAAU,CAAC;AAErC,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAStB,CAAC;AAEF,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAqC,CAAC"}

package/dist/models/users/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserModel = exports.UserSchema = void 0;
+const mongoose = require("mongoose");
+exports.UserSchema = new mongoose.Schema({
+    email: String,
+    passwordHash: { type: String, minlength: 6 },
+    firstName: { type: String, minlength: 3 },
+    lastName: { type: String, minlength: 3 },
+    lastLogin: Date,
+}, { timestamps: true });
+exports.UserModel = mongoose.model("User", exports.UserSchema);
+//# sourceMappingURL=index.js.map

package/dist/models/users/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/models/users/index.ts"],"names":[],"mappings":";;;AAAA,qCAAqC;AAExB,QAAA,UAAU,GAAG,IAAI,QAAQ,CAAC,MAAM,CAC3C;IACE,KAAK,EAAE,MAAM;IACb,YAAY,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC,EAAE;IAC5C,SAAS,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC,EAAE;IACzC,QAAQ,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC,EAAE;IACxC,SAAS,EAAE,IAAI;CAChB,EACD,EAAE,UAAU,EAAE,IAAI,EAAE,CACrB,CAAC;AAEW,QAAA,SAAS,GAAG,QAAQ,CAAC,KAAK,CAAC,MAAM,EAAE,kBAAU,CAAC,CAAC"}

package/dist/models/venues/index.d.ts

@@ -0,0 +1,167 @@
+import * as mongoose from "mongoose";
+export declare const VenueSchema: mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: true;
+}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name?: string;
+    hash?: string;
+    location?: {
+        enum: unknown[];
+        type?: string;
+        required?: unknown;
+    };
+    area?: string;
+    city?: string;
+    country?: string;
+    timezone?: string;
+    imageUrl?: string;
+    imageAttribution?: string;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name?: string;
+    hash?: string;
+    location?: {
+        enum: unknown[];
+        type?: string;
+        required?: unknown;
+    };
+    area?: string;
+    city?: string;
+    country?: string;
+    timezone?: string;
+    imageUrl?: string;
+    imageAttribution?: string;
+}>> & mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name?: string;
+    hash?: string;
+    location?: {
+        enum: unknown[];
+        type?: string;
+        required?: unknown;
+    };
+    area?: string;
+    city?: string;
+    country?: string;
+    timezone?: string;
+    imageUrl?: string;
+    imageAttribution?: string;
+}> & {
+    _id: mongoose.Types.ObjectId;
+}>;
+export declare const VenueModel: mongoose.Model<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name?: string;
+    hash?: string;
+    location?: {
+        enum: unknown[];
+        type?: string;
+        required?: unknown;
+    };
+    area?: string;
+    city?: string;
+    country?: string;
+    timezone?: string;
+    imageUrl?: string;
+    imageAttribution?: string;
+}, {}, {}, {}, mongoose.Document<unknown, {}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name?: string;
+    hash?: string;
+    location?: {
+        enum: unknown[];
+        type?: string;
+        required?: unknown;
+    };
+    area?: string;
+    city?: string;
+    country?: string;
+    timezone?: string;
+    imageUrl?: string;
+    imageAttribution?: string;
+}> & {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name?: string;
+    hash?: string;
+    location?: {
+        enum: unknown[];
+        type?: string;
+        required?: unknown;
+    };
+    area?: string;
+    city?: string;
+    country?: string;
+    timezone?: string;
+    imageUrl?: string;
+    imageAttribution?: string;
+} & {
+    _id: mongoose.Types.ObjectId;
+}, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    timestamps: true;
+}, {
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name?: string;
+    hash?: string;
+    location?: {
+        enum: unknown[];
+        type?: string;
+        required?: unknown;
+    };
+    area?: string;
+    city?: string;
+    country?: string;
+    timezone?: string;
+    imageUrl?: string;
+    imageAttribution?: string;
+}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name?: string;
+    hash?: string;
+    location?: {
+        enum: unknown[];
+        type?: string;
+        required?: unknown;
+    };
+    area?: string;
+    city?: string;
+    country?: string;
+    timezone?: string;
+    imageUrl?: string;
+    imageAttribution?: string;
+}>> & mongoose.FlatRecord<{
+    createdAt: NativeDate;
+    updatedAt: NativeDate;
+} & {
+    name?: string;
+    hash?: string;
+    location?: {
+        enum: unknown[];
+        type?: string;
+        required?: unknown;
+    };
+    area?: string;
+    city?: string;
+    country?: string;
+    timezone?: string;
+    imageUrl?: string;
+    imageAttribution?: string;
+}> & {
+    _id: mongoose.Types.ObjectId;
+}>>;
+//# sourceMappingURL=index.d.ts.map

package/dist/models/venues/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/models/venues/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,QAAQ,MAAM,UAAU,CAAC;AAErC,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuBvB,CAAC;AAEF,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAiD,CAAC"}

package/dist/models/venues/index.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VenueModel = exports.VenueSchema = void 0;
+const mongoose = require("mongoose");
+exports.VenueSchema = new mongoose.Schema({
+    name: String,
+    hash: { type: String, unique: true },
+    timezone: String,
+    location: {
+        type: {
+            type: String,
+            enum: ["Point"],
+            required: true,
+        },
+        coordinates: {
+            type: [Number],
+            required: true,
+        },
+    },
+    imageUrl: String,
+    imageAttribution: String,
+    area: String,
+    city: String,
+    country: String,
+}, { timestamps: true });
+exports.VenueModel = mongoose.model("Venue", exports.VenueSchema, "Venues");
+//# sourceMappingURL=index.js.map

package/dist/models/venues/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/models/venues/index.ts"],"names":[],"mappings":";;;AAAA,qCAAqC;AAExB,QAAA,WAAW,GAAG,IAAI,QAAQ,CAAC,MAAM,CAC5C;IACE,IAAI,EAAE,MAAM;IACZ,IAAI,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE;IACpC,QAAQ,EAAE,MAAM;IAChB,QAAQ,EAAE;QACR,IAAI,EAAE;YACJ,IAAI,EAAE,MAAM;YACZ,IAAI,EAAE,CAAC,OAAO,CAAC;YACf,QAAQ,EAAE,IAAI;SACf;QACD,WAAW,EAAE;YACX,IAAI,EAAE,CAAC,MAAM,CAAC;YACd,QAAQ,EAAE,IAAI;SACf;KACF;IACD,QAAQ,EAAE,MAAM;IAChB,gBAAgB,EAAE,MAAM;IACxB,IAAI,EAAE,MAAM;IACZ,IAAI,EAAE,MAAM;IACZ,OAAO,EAAE,MAAM;CAChB,EACD,EAAE,UAAU,EAAE,IAAI,EAAE,CACrB,CAAC;AAEW,QAAA,UAAU,GAAG,QAAQ,CAAC,KAAK,CAAC,OAAO,EAAE,mBAAW,EAAE,QAAQ,CAAC,CAAC"}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@weekendgoals/weekendgoals-common",
+  "version": "1.609.6797680924",
+  "description": "Weekend Goals Common",
+  "private": false,
+  "files": [
+    "dist",
+    "readme.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "lint": "eslint . --ext .js,.ts",
+    "lint:fix": "eslint . --ext .js,.ts --fix"
+  },
+  "author": "Leon Gordin",
+  "license": "ISC",
+  "dependencies": {
+    "@weekendgoals/weekendgoals-types": "latest",
+    "mongoose": "^7.6.4"
+  },
+  "devDependencies": {
+    "@types/node": "^18.14.2",
+    "@typescript-eslint/eslint-plugin": "^5.54.0",
+    "@typescript-eslint/parser": "^5.54.0",
+    "eslint": "^8.35.0",
+    "eslint-config-prettier": "^8.6.0",
+    "eslint-plugin-prettier": "^4.2.1",
+    "prettier": "^2.8.4",
+    "ts-jest": "^29.0.5",
+    "ts-node": "^10.9.1",
+    "typescript": "^4.9.5"
+  }
+}

package/readme.md

@@ -0,0 +1 @@
+# Weekend Goals Common