@playcademy/sdk 0.0.1-beta.24 → 0.0.1-beta.26

package/dist/types.d.ts

@@ -1,5 +1,6 @@
-import type { User, InventoryItemWithItem, Game, DeveloperKey, DeveloperStatusResponse, MapElement, Item, InsertItem, ManifestV1, UpdateItem, Currency, InsertCurrency, UpdateCurrency, ShopListing, InsertShopListing, UpdateShopListing, UserLevel, LevelConfig, XPAddResult, UserLevelWithConfig, XPActionInput } from '@playcademy/types';
-export { ITEM_INTERNAL_NAMES, CURRENCIES, BADGES, } from '@playcademy/data/constants';
+export type * from '@playcademy/data/types';
+export { CURRENCIES, BADGES } from '@playcademy/data/constants';
+export type { PlaycademyClient } from './core/client';
 export interface ClientConfig {
     baseUrl: string;
     token?: string;
@@ -33,11 +34,6 @@ export type GameContextPayload = {
 export type EventListeners = {
     [E in keyof ClientEvents]?: Array<(payload: ClientEvents[E]) => void>;
 };
-export type GameWithManifest = Game & {
-    manifest: ManifestV1;
-};
-export type DeveloperStatusValue = DeveloperStatusResponse['status'];
-export type GameState = Record<string, unknown>;
 export type LoginResponse = {
     token: string;
 };
@@ -51,32 +47,3 @@ export type StartSessionResponse = {
 export type InventoryMutationResponse = {
     newTotal: number;
 };
-export interface ShopDisplayItem extends Item {
-    listingId: string;
-    shopPrice: number;
-    currencyId: string;
-    currencySymbol?: string | null;
-    currencyDisplayName?: string | null;
-    currencyImageUrl?: string | null;
-    stock?: number | null;
-    sellBackPercentage?: number | null;
-}
-export interface UserCurrencyInfo {
-    id: string;
-    balance: number;
-    symbol?: string | null;
-    imageUrl?: string | null;
-    isPrimary: boolean;
-}
-export interface CurrencyInfo {
-    id: string;
-    symbol?: string | null;
-    imageUrl?: string | null;
-    displayName?: string | null;
-    isPrimary: boolean;
-}
-export interface ShopViewResponse {
-    shopItems: ShopDisplayItem[];
-    currencies: CurrencyInfo[];
-}
-export type { User, InventoryItemWithItem, Game, ManifestV1, DeveloperKey, DeveloperStatusResponse, MapElement, Item, InsertItem, UpdateItem, Currency, InsertCurrency, UpdateCurrency, ShopListing, InsertShopListing, UpdateShopListing, UserLevel, LevelConfig, XPAddResult, UserLevelWithConfig, XPActionInput, };

package/dist/types.js

@@ -10,10 +10,365 @@ var __export = (target, all) => {
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
+// ../data/src/domains/user/table.ts
+import { boolean, pgEnum, pgTable, text, timestamp, uniqueIndex } from "drizzle-orm/pg-core";
+var userRoleEnum, developerStatusEnum, users, accounts, sessions, verification;
+var init_table = __esm(() => {
+  userRoleEnum = pgEnum("user_role", ["admin", "player", "developer"]);
+  developerStatusEnum = pgEnum("developer_status", ["none", "pending", "approved"]);
+  users = pgTable("user", {
+    id: text("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+    name: text("name").notNull(),
+    username: text("username").unique(),
+    email: text("email").notNull().unique(),
+    emailVerified: boolean("email_verified").notNull().default(false),
+    image: text("image"),
+    role: userRoleEnum("role").notNull().default("player"),
+    developerStatus: developerStatusEnum("developer_status").notNull().default("none"),
+    createdAt: timestamp("created_at", {
+      mode: "date",
+      withTimezone: true
+    }).notNull(),
+    updatedAt: timestamp("updated_at", {
+      mode: "date",
+      withTimezone: true
+    }).notNull()
+  });
+  accounts = pgTable("account", {
+    id: text("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+    userId: text("userId").notNull().references(() => users.id, { onDelete: "cascade" }),
+    accountId: text("account_id").notNull(),
+    providerId: text("provider_id").notNull(),
+    accessToken: text("access_token"),
+    refreshToken: text("refresh_token"),
+    idToken: text("id_token"),
+    accessTokenExpiresAt: timestamp("access_token_expires_at", {
+      mode: "date",
+      withTimezone: true
+    }),
+    refreshTokenExpiresAt: timestamp("refresh_token_expires_at", {
+      mode: "date",
+      withTimezone: true
+    }),
+    scope: text("scope"),
+    password: text("password"),
+    createdAt: timestamp("created_at", {
+      mode: "date",
+      withTimezone: true
+    }).notNull(),
+    updatedAt: timestamp("updated_at", {
+      mode: "date",
+      withTimezone: true
+    }).notNull()
+  }, (table) => [uniqueIndex("account_provider_providerId_idx").on(table.accountId, table.providerId)]);
+  sessions = pgTable("session", {
+    id: text("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+    userId: text("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+    expiresAt: timestamp("expires_at", {
+      mode: "date",
+      withTimezone: true
+    }).notNull(),
+    token: text("token").notNull().unique(),
+    ipAddress: text("ip_address"),
+    userAgent: text("user_agent"),
+    createdAt: timestamp("created_at", {
+      mode: "date",
+      withTimezone: true
+    }).notNull(),
+    updatedAt: timestamp("updated_at", {
+      mode: "date",
+      withTimezone: true
+    }).notNull()
+  });
+  verification = pgTable("verification", {
+    id: text("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+    identifier: text("identifier").notNull(),
+    value: text("value").notNull(),
+    expiresAt: timestamp("expires_at", {
+      mode: "date",
+      withTimezone: true
+    }).notNull(),
+    createdAt: timestamp("created_at", {
+      mode: "date",
+      withTimezone: true
+    }).notNull(),
+    updatedAt: timestamp("updated_at", {
+      mode: "date",
+      withTimezone: true
+    }).notNull()
+  });
+});
+
+// ../data/src/domains/developer/table.ts
+import { pgTable as pgTable2, text as text2, timestamp as timestamp2, uuid, varchar } from "drizzle-orm/pg-core";
+var developerKeys;
+var init_table2 = __esm(() => {
+  init_table();
+  developerKeys = pgTable2("developer_keys", {
+    id: uuid("id").primaryKey().defaultRandom(),
+    userId: text2("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+    label: varchar("label", { length: 255 }),
+    keyHash: text2("key_hash").notNull().unique(),
+    createdAt: timestamp2("created_at", { withTimezone: true }).notNull().defaultNow()
+  });
+});
+
+// ../data/src/domains/map/table.ts
+import { relations } from "drizzle-orm";
+import {
+  doublePrecision,
+  jsonb,
+  pgEnum as pgEnum2,
+  pgTable as pgTable3,
+  text as text3,
+  uniqueIndex as uniqueIndex2,
+  uuid as uuid2,
+  varchar as varchar2
+} from "drizzle-orm/pg-core";
+var interactionTypeEnum, maps, mapElements, mapElementsRelations, mapsRelations;
+var init_table3 = __esm(() => {
+  init_table4();
+  interactionTypeEnum = pgEnum2("interaction_type", [
+    "game_entry",
+    "game_registry",
+    "info",
+    "teleport",
+    "door_in",
+    "door_out",
+    "npc_interaction",
+    "quest_trigger"
+  ]);
+  maps = pgTable3("maps", {
+    id: uuid2("id").primaryKey().defaultRandom(),
+    identifier: varchar2("identifier", { length: 255 }).notNull().unique(),
+    displayName: varchar2("display_name", { length: 255 }).notNull(),
+    filePath: varchar2("file_path", { length: 255 }).notNull(),
+    tilesetBasePath: varchar2("tileset_base_path", { length: 255 }).notNull().default("/tilesets"),
+    defaultSpawnTileX: doublePrecision("default_spawn_tile_x").notNull().default(0),
+    defaultSpawnTileY: doublePrecision("default_spawn_tile_y").notNull().default(0),
+    description: text3("description")
+  });
+  mapElements = pgTable3("map_elements", {
+    id: uuid2("id").primaryKey().defaultRandom(),
+    mapId: uuid2("map_id").references(() => maps.id, {
+      onDelete: "cascade"
+    }),
+    elementSlug: varchar2("element_slug", { length: 255 }).notNull(),
+    interactionType: interactionTypeEnum("interaction_type").notNull(),
+    gameId: uuid2("game_id").references(() => games.id, {
+      onDelete: "set null"
+    }),
+    metadata: jsonb("metadata").$type().default({})
+  }, (table) => [uniqueIndex2("map_id_element_slug_unique_idx").on(table.mapId, table.elementSlug)]);
+  mapElementsRelations = relations(mapElements, ({ one }) => ({
+    game: one(games, {
+      fields: [mapElements.gameId],
+      references: [games.id]
+    }),
+    map: one(maps, {
+      fields: [mapElements.mapId],
+      references: [maps.id]
+    })
+  }));
+  mapsRelations = relations(maps, ({ many }) => ({
+    elements: many(mapElements)
+  }));
+});
+
+// ../data/src/domains/game/table.ts
+import {
+  jsonb as jsonb2,
+  pgEnum as pgEnum3,
+  pgTable as pgTable4,
+  text as text4,
+  timestamp as timestamp3,
+  uniqueIndex as uniqueIndex3,
+  uuid as uuid3,
+  varchar as varchar3
+} from "drizzle-orm/pg-core";
+var gamePlatformEnum, gameBootModeEnum, games, gameSessions, gameStates;
+var init_table4 = __esm(() => {
+  init_table3();
+  init_table();
+  gamePlatformEnum = pgEnum3("game_platform", ["web", "godot", "unity"]);
+  gameBootModeEnum = pgEnum3("game_boot_mode", ["iframe", "module"]);
+  games = pgTable4("games", {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    developerId: text4("developer_id").references(() => users.id, {
+      onDelete: "set null"
+    }),
+    slug: varchar3("slug", { length: 255 }).notNull().unique(),
+    displayName: varchar3("display_name", { length: 255 }).notNull(),
+    version: varchar3("version", { length: 50 }).notNull(),
+    assetBundleBase: text4("asset_bundle_base").notNull(),
+    platform: gamePlatformEnum("platform").notNull().default("web"),
+    mapElementId: uuid3("map_element_id").references(() => mapElements.id, {
+      onDelete: "set null"
+    }),
+    metadata: jsonb2("metadata").default("{}"),
+    createdAt: timestamp3("created_at", { withTimezone: true }).defaultNow(),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).defaultNow()
+  });
+  gameSessions = pgTable4("game_sessions", {
+    id: uuid3("id").primaryKey().defaultRandom(),
+    userId: text4("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+    gameId: uuid3("game_id").notNull().references(() => games.id, { onDelete: "cascade" }),
+    startedAt: timestamp3("started_at", { withTimezone: true }).notNull().defaultNow(),
+    endedAt: timestamp3("ended_at", { withTimezone: true })
+  });
+  gameStates = pgTable4("game_states", {
+    userId: text4("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+    gameId: uuid3("game_id").notNull().references(() => games.id, { onDelete: "cascade" }),
+    data: jsonb2("data").default("{}"),
+    updatedAt: timestamp3("updated_at", { withTimezone: true }).defaultNow()
+  }, (table) => [uniqueIndex3("unique_user_game_idx").on(table.userId, table.gameId)]);
+});
+
+// ../data/src/domains/inventory/table.ts
+import { relations as relations2, sql } from "drizzle-orm";
+import {
+  boolean as boolean2,
+  integer,
+  jsonb as jsonb3,
+  pgEnum as pgEnum4,
+  pgTable as pgTable5,
+  text as text5,
+  timestamp as timestamp4,
+  uniqueIndex as uniqueIndex4,
+  uuid as uuid4
+} from "drizzle-orm/pg-core";
+var itemTypeEnum, items, inventoryItems, currencies, shopListings, itemsRelations, currenciesRelations, shopListingsRelations, inventoryItemsRelations;
+var init_table5 = __esm(() => {
+  init_table4();
+  init_table();
+  itemTypeEnum = pgEnum4("item_type", [
+    "currency",
+    "badge",
+    "trophy",
+    "collectible",
+    "consumable",
+    "unlock",
+    "upgrade",
+    "other"
+  ]);
+  items = pgTable5("items", {
+    id: uuid4("id").primaryKey().defaultRandom(),
+    slug: text5("slug").notNull(),
+    gameId: uuid4("game_id").references(() => games.id, {
+      onDelete: "cascade"
+    }),
+    displayName: text5("display_name").notNull(),
+    description: text5("description"),
+    type: itemTypeEnum("type").notNull().default("other"),
+    imageUrl: text5("image_url"),
+    metadata: jsonb3("metadata").default({}),
+    createdAt: timestamp4("created_at").defaultNow().notNull()
+  }, (table) => [
+    uniqueIndex4("items_game_slug_idx").on(table.gameId, table.slug),
+    uniqueIndex4("items_global_slug_idx").on(table.slug).where(sql`game_id IS NULL`)
+  ]);
+  inventoryItems = pgTable5("inventory_items", {
+    id: uuid4("id").primaryKey().defaultRandom(),
+    userId: text5("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+    itemId: uuid4("item_id").notNull().references(() => items.id, { onDelete: "cascade" }),
+    quantity: integer("quantity").notNull().default(1),
+    updatedAt: timestamp4("updated_at", { withTimezone: true }).defaultNow()
+  }, (table) => [uniqueIndex4("unique_user_item_idx").on(table.userId, table.itemId)]);
+  currencies = pgTable5("currencies", {
+    id: uuid4("id").primaryKey().defaultRandom(),
+    itemId: uuid4("item_id").notNull().references(() => items.id, { onDelete: "cascade" }),
+    symbol: text5("symbol"),
+    isPrimary: boolean2("is_primary").default(false).notNull(),
+    createdAt: timestamp4("created_at").defaultNow().notNull(),
+    updatedAt: timestamp4("updated_at", { withTimezone: true }).defaultNow().$onUpdate(() => new Date)
+  }, (table) => [uniqueIndex4("currency_item_id_idx").on(table.itemId)]);
+  shopListings = pgTable5("shop_listings", {
+    id: uuid4("id").primaryKey().defaultRandom(),
+    itemId: uuid4("item_id").notNull().references(() => items.id, { onDelete: "cascade" }),
+    currencyId: uuid4("currency_id").notNull().references(() => currencies.id, { onDelete: "restrict" }),
+    price: integer("price").notNull(),
+    sellBackPercentage: integer("sell_back_percentage"),
+    stock: integer("stock"),
+    isActive: boolean2("is_active").default(true).notNull(),
+    availableFrom: timestamp4("available_from", { withTimezone: true }),
+    availableUntil: timestamp4("available_until", { withTimezone: true }),
+    createdAt: timestamp4("created_at").defaultNow().notNull(),
+    updatedAt: timestamp4("updated_at", { withTimezone: true }).defaultNow().$onUpdate(() => new Date)
+  }, (table) => [uniqueIndex4("unique_item_currency_listing_idx").on(table.itemId, table.currencyId)]);
+  itemsRelations = relations2(items, ({ many }) => ({
+    shopListings: many(shopListings),
+    inventoryItems: many(inventoryItems)
+  }));
+  currenciesRelations = relations2(currencies, ({ many }) => ({
+    shopListings: many(shopListings)
+  }));
+  shopListingsRelations = relations2(shopListings, ({ one }) => ({
+    item: one(items, {
+      fields: [shopListings.itemId],
+      references: [items.id]
+    }),
+    currency: one(currencies, {
+      fields: [shopListings.currencyId],
+      references: [currencies.id]
+    })
+  }));
+  inventoryItemsRelations = relations2(inventoryItems, ({ one }) => ({
+    item: one(items, {
+      fields: [inventoryItems.itemId],
+      references: [items.id]
+    }),
+    user: one(users, {
+      fields: [inventoryItems.userId],
+      references: [users.id]
+    })
+  }));
+});
+
+// ../data/src/domains/level/table.ts
+import { relations as relations3 } from "drizzle-orm";
+import { integer as integer2, pgTable as pgTable6, text as text6, timestamp as timestamp5, uniqueIndex as uniqueIndex5, uuid as uuid5 } from "drizzle-orm/pg-core";
+var userLevels, levelConfigs, userLevelsRelations;
+var init_table6 = __esm(() => {
+  init_table();
+  userLevels = pgTable6("user_levels", {
+    userId: text6("user_id").primaryKey().references(() => users.id, { onDelete: "cascade" }),
+    currentLevel: integer2("current_level").notNull().default(1),
+    currentXp: integer2("current_xp").notNull().default(0),
+    totalXP: integer2("total_xp").notNull().default(0),
+    lastLevelUpAt: timestamp5("last_level_up_at", { withTimezone: true }),
+    createdAt: timestamp5("created_at").defaultNow().notNull(),
+    updatedAt: timestamp5("updated_at", { withTimezone: true }).defaultNow().$onUpdate(() => new Date)
+  });
+  levelConfigs = pgTable6("level_configs", {
+    id: uuid5("id").primaryKey().defaultRandom(),
+    level: integer2("level").notNull().unique(),
+    xpRequired: integer2("xp_required").notNull(),
+    creditsReward: integer2("credits_reward").notNull().default(0),
+    createdAt: timestamp5("created_at").defaultNow().notNull()
+  }, (table) => [uniqueIndex5("unique_level_config_idx").on(table.level)]);
+  userLevelsRelations = relations3(userLevels, ({ one }) => ({
+    user: one(users, {
+      fields: [userLevels.userId],
+      references: [users.id]
+    })
+  }));
+});
+
+// ../data/src/tables.index.ts
+var init_tables_index = __esm(() => {
+  init_table();
+  init_table2();
+  init_table4();
+  init_table5();
+  init_table3();
+  init_table6();
+});
+
 // ../data/src/constants.ts
-var ITEM_INTERNAL_NAMES, CURRENCIES, BADGES;
+var ITEM_SLUGS, CURRENCIES, BADGES, INTERACTION_TYPE;
 var init_constants = __esm(() => {
-  ITEM_INTERNAL_NAMES = {
+  init_tables_index();
+  ITEM_SLUGS = {
     PLAYCADEMY_CREDITS: "PLAYCADEMY_CREDITS",
     PLAYCADEMY_XP: "PLAYCADEMY_XP",
     FOUNDING_MEMBER_BADGE: "FOUNDING_MEMBER_BADGE",
@@ -24,20 +379,20 @@ var init_constants = __esm(() => {
     SMALL_BACKPACK: "SMALL_BACKPACK"
   };
   CURRENCIES = {
-    PRIMARY: ITEM_INTERNAL_NAMES.PLAYCADEMY_CREDITS,
-    XP: ITEM_INTERNAL_NAMES.PLAYCADEMY_XP
+    PRIMARY: ITEM_SLUGS.PLAYCADEMY_CREDITS,
+    XP: ITEM_SLUGS.PLAYCADEMY_XP
   };
   BADGES = {
-    FOUNDING_MEMBER: ITEM_INTERNAL_NAMES.FOUNDING_MEMBER_BADGE,
-    EARLY_ADOPTER: ITEM_INTERNAL_NAMES.EARLY_ADOPTER_BADGE,
-    FIRST_GAME: ITEM_INTERNAL_NAMES.FIRST_GAME_BADGE
+    FOUNDING_MEMBER: ITEM_SLUGS.FOUNDING_MEMBER_BADGE,
+    EARLY_ADOPTER: ITEM_SLUGS.EARLY_ADOPTER_BADGE,
+    FIRST_GAME: ITEM_SLUGS.FIRST_GAME_BADGE
   };
+  INTERACTION_TYPE = Object.fromEntries(interactionTypeEnum.enumValues.map((value) => [value, value]));
 });
 
 // src/types.ts
 init_constants();
 export {
-  ITEM_INTERNAL_NAMES,
   CURRENCIES,
   BADGES
 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@playcademy/sdk",
-    "version": "0.0.1-beta.24",
+    "version": "0.0.1-beta.26",
     "type": "module",
     "exports": {
         ".": {
@@ -24,14 +24,16 @@
         "bump": "bunx bumpp --no-tag --no-push -c \"chore(@playcademy/sdk): release v%s\"",
         "pub": "bun run build && bun run bump && bun publish --access public"
     },
+    "dependencies": {
+        "@playcademy/logger": "0.0.1"
+    },
     "devDependencies": {
-        "@playcademy/types": "^0.0.1-beta.6",
+        "@playcademy/data": "0.0.1",
         "@types/bun": "latest",
         "typescript": "^5.7.2",
         "yocto-spinner": "^0.2.2"
     },
     "peerDependencies": {
-        "@playcademy/types": "latest",
         "drizzle-orm": "^0.42.0",
         "typescript": "^5"
     }