@lcas58/esmi-api-types 1.0.4 → 1.0.6

package/dist/src/db/schema/organization.js

@@ -0,0 +1,174 @@
+import { relations } from "drizzle-orm";
+import { index, pgTable, text, timestamp, uniqueIndex, varchar } from "drizzle-orm/pg-core";
+import { createInsertSchema, createSelectSchema } from "drizzle-zod";
+import { randomUUID } from "node:crypto";
+import { z } from "zod";
+import event from "./event.js";
+import tags, { organizationTags } from "./tag.js";
+import { user } from "./user.js";
+const organization = pgTable("organization", {
+    id: text("id").primaryKey().$defaultFn(() => randomUUID()),
+    name: varchar("name").notNull(),
+    description: text("description").notNull(),
+    ownerId: varchar("owner_id").references(() => user.id).notNull(),
+    slug: varchar("slug").notNull(), // normalized name with no spaces or special characters (unique)
+    status: varchar("status").notNull().default("inactive"),
+    avatar: varchar("avatar"), // DiceBear seed or R2 URL
+    city: varchar("city", { length: 120 }),
+    state: varchar("state", { length: 120 }),
+    stateCd: varchar("state_cd", { length: 120 }),
+    country: varchar("country", { length: 120 }),
+    createdAt: timestamp("created_at").$defaultFn(() => new Date()),
+    updatedAt: timestamp("updated_at").$defaultFn(() => new Date()).$onUpdateFn(() => new Date()),
+}, table => ({
+    locationIdx: index("organization_location_idx").on(table.city, table.state, table.country),
+    orgSlugKey: uniqueIndex("organization_slug_key").on(table.slug),
+}));
+// New table for organization websites
+export const organizationWebsites = pgTable("organization_websites", {
+    id: text("id").primaryKey().$defaultFn(() => randomUUID()),
+    organizationId: text("organization_id").references(() => organization.id, { onDelete: "cascade" }).notNull(),
+    url: varchar("url").notNull(),
+    label: varchar("label", { length: 100 }), // e.g., "Main Website", "Blog"
+    createdAt: timestamp("created_at").$defaultFn(() => new Date()),
+    updatedAt: timestamp("updated_at").$defaultFn(() => new Date()).$onUpdateFn(() => new Date()),
+});
+// New table for organization social media
+export const organizationSocialMedia = pgTable("organization_social_media", {
+    id: text("id").primaryKey().$defaultFn(() => randomUUID()),
+    organizationId: text("organization_id").references(() => organization.id, { onDelete: "cascade" }).notNull(),
+    platform: varchar("platform", { length: 50 }).notNull(), // e.g., "twitter", "facebook", "linkedin"
+    url: varchar("url"), // Optional - can be built dynamically from platform + handle
+    handle: varchar("handle", { length: 100 }).notNull(), // e.g., "@companyname" or "companyname"
+    createdAt: timestamp("created_at").$defaultFn(() => new Date()),
+    updatedAt: timestamp("updated_at").$defaultFn(() => new Date()).$onUpdateFn(() => new Date()),
+});
+export const organizationRelations = relations(organization, ({ one, many }) => ({
+    owner: one(user, {
+        fields: [organization.ownerId],
+        references: [user.id],
+    }),
+    events: many(event),
+    tags: many(organizationTags),
+    websites: many(organizationWebsites),
+    socialMedia: many(organizationSocialMedia),
+}));
+export const organizationWebsitesRelations = relations(organizationWebsites, ({ one }) => ({
+    organization: one(organization, {
+        fields: [organizationWebsites.organizationId],
+        references: [organization.id],
+    }),
+}));
+export const organizationSocialMediaRelations = relations(organizationSocialMedia, ({ one }) => ({
+    organization: one(organization, {
+        fields: [organizationSocialMedia.organizationId],
+        references: [organization.id],
+    }),
+}));
+export const organizationTagsRelations = relations(organizationTags, ({ one }) => ({
+    organization: one(organization, {
+        fields: [organizationTags.organizationId],
+        references: [organization.id],
+    }),
+    tag: one(tags, {
+        fields: [organizationTags.tagId],
+        references: [tags.id],
+    }),
+}));
+export const selectOrganizationSchema = createSelectSchema(organization);
+export const insertOrganizationSchema = createInsertSchema(organization, {
+    name: schema => schema.name.min(5).max(500),
+    description: schema => schema.description.max(500),
+    city: schema => schema.city.min(2).max(120),
+    state: schema => schema.state.max(120),
+    stateCd: schema => schema.stateCd.max(120),
+    country: schema => schema.country.min(2).max(120),
+}).required({
+    name: true,
+    description: true,
+    city: true,
+    stateCd: true,
+    country: true,
+}).omit({
+    id: true,
+    slug: true,
+    ownerId: true,
+    createdAt: true,
+    updatedAt: true,
+});
+// New schemas for related data
+export const insertOrganizationWebsiteSchema = createInsertSchema(organizationWebsites, {
+    url: schema => schema.url.min(1).max(500),
+    label: schema => schema.label.max(100),
+}).omit({
+    id: true,
+    organizationId: true,
+    createdAt: true,
+    updatedAt: true,
+});
+// Supported social media platforms
+export const SOCIAL_MEDIA_PLATFORMS = [
+    "x",
+    "facebook",
+    "instagram",
+];
+export const insertOrganizationSocialMediaSchema = createInsertSchema(organizationSocialMedia, {
+    platform: schema => schema.platform.min(1).max(50).refine(val => SOCIAL_MEDIA_PLATFORMS.includes(val), { message: `Platform must be one of: ${SOCIAL_MEDIA_PLATFORMS.join(", ")}` }),
+    url: schema => schema.url.max(500),
+    handle: schema => schema.handle.min(1).max(100),
+}).omit({
+    id: true,
+    organizationId: true,
+    createdAt: true,
+    updatedAt: true,
+});
+// Helper function to generate social media URLs dynamically
+export function generateSocialMediaUrl(platform, handle) {
+    const cleanHandle = handle.startsWith("@") ? handle.slice(1) : handle;
+    switch (platform.toLowerCase()) {
+        case "x":
+            return `https://x.com/${cleanHandle}`;
+        case "facebook":
+            return `https://facebook.com/${cleanHandle}`;
+        case "instagram":
+            return `https://instagram.com/${cleanHandle}`;
+        default:
+            return `https://${platform}.com/${cleanHandle}`;
+    }
+}
+export const insertOrganizationTagSchema = createInsertSchema(organizationTags, {
+    tagId: schema => schema.tagId.min(1),
+}).omit({
+    organizationId: true,
+    createdAt: true,
+    updatedAt: true,
+});
+export const getOrganizationWithDetailsSchema = selectOrganizationSchema.extend({
+    tags: z.array(z.object({
+        id: z.string(),
+        name: z.string(),
+    })),
+    websites: z.array(z.object({
+        id: z.string(),
+        url: z.string(),
+        label: z.string(),
+    })),
+    socialMedia: z.array(z.object({
+        id: z.string(),
+        platform: z.string(),
+        url: z.string(),
+        handle: z.string(),
+    })),
+});
+// Extended schema for creating organization with all details
+export const createOrganizationWithDetailsSchema = insertOrganizationSchema.extend({
+    tags: insertOrganizationTagSchema.array().optional(),
+    websites: insertOrganizationWebsiteSchema.array().optional(),
+    socialMedia: insertOrganizationSocialMediaSchema.array().optional(),
+});
+export const patchOrganizationSchema = insertOrganizationSchema.partial().extend({
+    tags: insertOrganizationTagSchema.array().optional(),
+    websites: insertOrganizationWebsiteSchema.array().optional(),
+    socialMedia: insertOrganizationSocialMediaSchema.array().optional(),
+});
+export default organization;

package/dist/src/db/schema/pickup.d.ts

@@ -0,0 +1,417 @@
+declare const pickup: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "pickup";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "pickup";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            generated: undefined;
+        }, {}, {}>;
+        eventId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "event_id";
+            tableName: "pickup";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            generated: undefined;
+        }, {}, {}>;
+        maxPlayers: import("drizzle-orm/pg-core").PgColumn<{
+            name: "max_players";
+            tableName: "pickup";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            generated: undefined;
+        }, {}, {}>;
+        minPlayers: import("drizzle-orm/pg-core").PgColumn<{
+            name: "min_players";
+            tableName: "pickup";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            generated: undefined;
+        }, {}, {}>;
+        currentPlayers: import("drizzle-orm/pg-core").PgColumn<{
+            name: "current_players";
+            tableName: "pickup";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            generated: undefined;
+        }, {}, {}>;
+        fieldSize: import("drizzle-orm/pg-core").PgColumn<{
+            name: "field_size";
+            tableName: "pickup";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            generated: undefined;
+        }, {}, {}>;
+        gameLength: import("drizzle-orm/pg-core").PgColumn<{
+            name: "game_length";
+            tableName: "pickup";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            generated: undefined;
+        }, {}, {}>;
+        skillLevel: import("drizzle-orm/pg-core").PgColumn<{
+            name: "skill_level";
+            tableName: "pickup";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            generated: undefined;
+        }, {}, {}>;
+        images: import("drizzle-orm/pg-core").PgColumn<{
+            name: "images";
+            tableName: "pickup";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            generated: undefined;
+        }, {}, {}>;
+        equipmentProvided: import("drizzle-orm/pg-core").PgColumn<{
+            name: "equipment_provided";
+            tableName: "pickup";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            generated: undefined;
+        }, {}, {}>;
+        equipmentRequired: import("drizzle-orm/pg-core").PgColumn<{
+            name: "equipment_required";
+            tableName: "pickup";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            generated: undefined;
+        }, {}, {}>;
+        cost: import("drizzle-orm/pg-core").PgColumn<{
+            name: "cost";
+            tableName: "pickup";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            generated: undefined;
+        }, {}, {}>;
+        costPerPlayer: import("drizzle-orm/pg-core").PgColumn<{
+            name: "cost_per_player";
+            tableName: "pickup";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            generated: undefined;
+        }, {}, {}>;
+        rules: import("drizzle-orm/pg-core").PgColumn<{
+            name: "rules";
+            tableName: "pickup";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            generated: undefined;
+        }, {}, {}>;
+        weatherDependent: import("drizzle-orm/pg-core").PgColumn<{
+            name: "weather_dependent";
+            tableName: "pickup";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            generated: undefined;
+        }, {}, {}>;
+        startTime: import("drizzle-orm/pg-core").PgColumn<{
+            name: "start_time";
+            tableName: "pickup";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            generated: undefined;
+        }, {}, {}>;
+        endTime: import("drizzle-orm/pg-core").PgColumn<{
+            name: "end_time";
+            tableName: "pickup";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            generated: undefined;
+        }, {}, {}>;
+        status: import("drizzle-orm/pg-core").PgColumn<{
+            name: "status";
+            tableName: "pickup";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            generated: undefined;
+        }, {}, {}>;
+        notes: import("drizzle-orm/pg-core").PgColumn<{
+            name: "notes";
+            tableName: "pickup";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "pickup";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "pickup";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export declare const pickupRelations: import("drizzle-orm").Relations<"pickup", {
+    event: import("drizzle-orm").One<"event", true>;
+}>;
+export declare const eventPickupRelations: import("drizzle-orm").Relations<"event", {
+    pickup: import("drizzle-orm").One<"pickup", true>;
+}>;
+export declare const selectPickupSchema: import("zod").ZodObject<{
+    id: import("zod").ZodString;
+    eventId: import("zod").ZodString;
+    maxPlayers: import("zod").ZodNumber;
+    minPlayers: import("zod").ZodNumber;
+    currentPlayers: import("zod").ZodNumber;
+    fieldSize: import("zod").ZodString;
+    gameLength: import("zod").ZodNumber;
+    skillLevel: import("zod").ZodString;
+    images: import("zod").ZodNullable<import("zod").ZodString>;
+    equipmentProvided: import("zod").ZodNullable<import("zod").ZodString>;
+    equipmentRequired: import("zod").ZodNullable<import("zod").ZodString>;
+    cost: import("zod").ZodNullable<import("zod").ZodNumber>;
+    costPerPlayer: import("zod").ZodBoolean;
+    rules: import("zod").ZodNullable<import("zod").ZodString>;
+    weatherDependent: import("zod").ZodBoolean;
+    startTime: import("zod").ZodDate;
+    endTime: import("zod").ZodDate;
+    status: import("zod").ZodString;
+    notes: import("zod").ZodNullable<import("zod").ZodString>;
+    createdAt: import("zod").ZodDate;
+    updatedAt: import("zod").ZodDate;
+}, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {
+    id: string;
+    status: string;
+    createdAt: Date;
+    updatedAt: Date;
+    eventId: string;
+    maxPlayers: number;
+    minPlayers: number;
+    currentPlayers: number;
+    fieldSize: string;
+    gameLength: number;
+    skillLevel: string;
+    images: string | null;
+    equipmentProvided: string | null;
+    equipmentRequired: string | null;
+    cost: number | null;
+    costPerPlayer: boolean;
+    rules: string | null;
+    weatherDependent: boolean;
+    startTime: Date;
+    endTime: Date;
+    notes: string | null;
+}, {
+    id: string;
+    status: string;
+    createdAt: Date;
+    updatedAt: Date;
+    eventId: string;
+    maxPlayers: number;
+    minPlayers: number;
+    currentPlayers: number;
+    fieldSize: string;
+    gameLength: number;
+    skillLevel: string;
+    images: string | null;
+    equipmentProvided: string | null;
+    equipmentRequired: string | null;
+    cost: number | null;
+    costPerPlayer: boolean;
+    rules: string | null;
+    weatherDependent: boolean;
+    startTime: Date;
+    endTime: Date;
+    notes: string | null;
+}>;
+export default pickup;

package/dist/src/db/schema/pickup.js

@@ -0,0 +1,42 @@
+import { relations } from "drizzle-orm";
+import { boolean, integer, pgTable, text, timestamp, varchar } from "drizzle-orm/pg-core";
+import { createSelectSchema } from "drizzle-zod";
+import { randomUUID } from "node:crypto";
+import event from "./event.js";
+const pickup = pgTable("pickup", {
+    id: text("id").primaryKey().$defaultFn(() => randomUUID()),
+    eventId: text("event_id").references(() => event.id, { onDelete: "cascade" }).notNull(),
+    maxPlayers: integer("max_players").notNull().default(22), // Maximum participants (default for soccer 11v11)
+    minPlayers: integer("min_players").notNull().default(4), // Minimum participants to start
+    currentPlayers: integer("current_players").notNull().default(0),
+    fieldSize: varchar("field_size", { length: 50 }).notNull().default("full"), // full, half, small, court, etc.
+    gameLength: integer("game_length").notNull().default(90), // Duration in minutes
+    skillLevel: varchar("skill_level", { length: 20 }).notNull().default("mixed"), // beginner, intermediate, advanced, mixed
+    images: text("images"), // Array of images
+    equipmentProvided: varchar("equipment_provided", { length: 255 }), // Equipment provided by organizer
+    equipmentRequired: varchar("equipment_required", { length: 255 }), // Equipment participants must bring
+    cost: integer("cost").default(0), // cost in cents
+    costPerPlayer: boolean("cost_per_player").notNull().default(true),
+    rules: text("rules"), // custom rules or modifications
+    weatherDependent: boolean("weather_dependent").notNull().default(true),
+    startTime: timestamp("start_time").notNull(),
+    endTime: timestamp("end_time").notNull(),
+    status: varchar("status", { length: 20 }).notNull().default("open"), // open, full, cancelled, completed
+    notes: text("notes"),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+    updatedAt: timestamp("updated_at").defaultNow().notNull(),
+});
+export const pickupRelations = relations(pickup, ({ one }) => ({
+    event: one(event, {
+        fields: [pickup.eventId],
+        references: [event.id],
+    }),
+}));
+export const eventPickupRelations = relations(event, ({ one }) => ({
+    pickup: one(pickup, {
+        fields: [event.id],
+        references: [pickup.eventId],
+    }),
+}));
+export const selectPickupSchema = createSelectSchema(pickup);
+export default pickup;