2020-04-22 13:03:32 -07:00
|
|
|
const { gql } = require("apollo-server");
|
2020-04-22 11:51:36 -07:00
|
|
|
|
|
|
|
const connectToDb = require("./db");
|
2020-04-23 14:23:46 -07:00
|
|
|
const buildLoaders = require("./loaders");
|
2020-04-25 06:50:34 -07:00
|
|
|
const neopets = require("./neopets");
|
2020-05-23 12:47:06 -07:00
|
|
|
const {
|
|
|
|
capitalize,
|
|
|
|
getPoseFromPetState,
|
2020-05-23 13:55:59 -07:00
|
|
|
getPoseFromPetData,
|
2020-05-23 12:47:06 -07:00
|
|
|
getEmotion,
|
|
|
|
getGenderPresentation,
|
|
|
|
} = require("./util");
|
2020-04-22 11:51:36 -07:00
|
|
|
|
|
|
|
const typeDefs = gql`
|
2020-04-23 01:08:00 -07:00
|
|
|
enum LayerImageSize {
|
|
|
|
SIZE_600
|
|
|
|
SIZE_300
|
|
|
|
SIZE_150
|
|
|
|
}
|
|
|
|
|
2020-05-23 12:47:06 -07:00
|
|
|
"""
|
|
|
|
The poses a PetAppearance can take!
|
|
|
|
"""
|
|
|
|
enum Pose {
|
|
|
|
HAPPY_MASC
|
|
|
|
SAD_MASC
|
|
|
|
SICK_MASC
|
|
|
|
HAPPY_FEM
|
|
|
|
SAD_FEM
|
|
|
|
SICK_FEM
|
|
|
|
UNCONVERTED
|
|
|
|
UNKNOWN # for when we have the data, but we don't know what it is
|
|
|
|
}
|
|
|
|
|
2020-05-02 16:49:57 -07:00
|
|
|
"""
|
|
|
|
A pet's gender presentation: masculine or feminine.
|
|
|
|
|
|
|
|
Neopets calls these "male" and "female", and I think that's silly and not wise
|
|
|
|
to propagate further, especially in the context of a strictly visual app like
|
|
|
|
Dress to Impress! This description isn't altogether correct either, but idk
|
|
|
|
what's better :/
|
|
|
|
"""
|
|
|
|
enum GenderPresentation {
|
|
|
|
MASCULINE
|
|
|
|
FEMININE
|
|
|
|
}
|
|
|
|
|
|
|
|
"""
|
|
|
|
A pet's emotion: happy, sad, or sick.
|
|
|
|
|
|
|
|
Note that we don't ever show the angry emotion on Dress to Impress, because
|
|
|
|
we don't have the data: it's impossible for a pet's passive emotion on the
|
|
|
|
pet lookup to be angry!
|
|
|
|
"""
|
|
|
|
enum Emotion {
|
|
|
|
HAPPY
|
|
|
|
SAD
|
|
|
|
SICK
|
|
|
|
}
|
|
|
|
|
2020-04-22 11:51:36 -07:00
|
|
|
type Item {
|
|
|
|
id: ID!
|
|
|
|
name: String!
|
2020-04-25 22:40:28 -07:00
|
|
|
description: String!
|
2020-04-22 14:55:12 -07:00
|
|
|
thumbnailUrl: String!
|
2020-05-31 15:56:40 -07:00
|
|
|
rarityIndex: Int!
|
|
|
|
isNc: Boolean!
|
2020-05-02 16:49:57 -07:00
|
|
|
appearanceOn(speciesId: ID!, colorId: ID!): ItemAppearance
|
2020-07-31 22:31:28 -07:00
|
|
|
|
|
|
|
# This is set manually by Support users, when the pet is only for e.g.
|
|
|
|
# Maraquan pets, and our usual auto-detection isn't working. We provide
|
|
|
|
# this for the Support UI; it's not very helpful for most users, because it
|
|
|
|
# can be empty even if the item _has_ an auto-detected special color.
|
|
|
|
manualSpecialColor: Color
|
2020-04-23 01:08:00 -07:00
|
|
|
}
|
|
|
|
|
2020-07-22 23:08:28 -07:00
|
|
|
# Cache for 1 week (unlikely to change)
|
|
|
|
type PetAppearance @cacheControl(maxAge: 604800) {
|
2020-05-02 20:48:32 -07:00
|
|
|
id: ID!
|
2020-06-24 19:05:07 -07:00
|
|
|
species: Species!
|
|
|
|
color: Color!
|
2020-05-23 12:47:06 -07:00
|
|
|
pose: Pose!
|
2020-06-24 19:05:07 -07:00
|
|
|
bodyId: ID!
|
|
|
|
|
2020-05-02 16:49:57 -07:00
|
|
|
layers: [AppearanceLayer!]!
|
2020-06-24 19:05:07 -07:00
|
|
|
petStateId: ID! # Convenience field for developers
|
2020-05-02 16:49:57 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
type ItemAppearance {
|
2020-04-23 14:23:46 -07:00
|
|
|
layers: [AppearanceLayer!]!
|
2020-04-23 14:44:06 -07:00
|
|
|
restrictedZones: [Zone!]!
|
2020-04-23 01:08:00 -07:00
|
|
|
}
|
|
|
|
|
2020-07-22 23:08:28 -07:00
|
|
|
# Cache for 1 week (unlikely to change)
|
|
|
|
type AppearanceLayer @cacheControl(maxAge: 604800) {
|
2020-04-23 01:08:00 -07:00
|
|
|
id: ID!
|
|
|
|
zone: Zone!
|
|
|
|
imageUrl(size: LayerImageSize): String
|
2020-05-11 21:19:34 -07:00
|
|
|
|
|
|
|
"""
|
|
|
|
This layer as a single SVG, if available.
|
|
|
|
|
|
|
|
This might not be available if the asset isn't converted yet by Neopets,
|
|
|
|
or if it's not as simple as a single SVG (e.g. animated).
|
|
|
|
"""
|
|
|
|
svgUrl: String
|
2020-08-01 14:12:57 -07:00
|
|
|
|
|
|
|
"""
|
|
|
|
This layer can fit on PetAppearances with the same bodyId. "0" is a
|
|
|
|
special body ID that indicates it fits all PetAppearances.
|
|
|
|
"""
|
|
|
|
bodyId: ID!
|
2020-04-23 01:08:00 -07:00
|
|
|
}
|
|
|
|
|
2020-07-22 23:08:28 -07:00
|
|
|
# Cache for 1 week (unlikely to change)
|
|
|
|
type Zone @cacheControl(maxAge: 604800) {
|
2020-04-23 01:08:00 -07:00
|
|
|
id: ID!
|
|
|
|
depth: Int!
|
|
|
|
label: String!
|
2020-04-22 11:51:36 -07:00
|
|
|
}
|
|
|
|
|
2020-04-25 01:55:48 -07:00
|
|
|
type ItemSearchResult {
|
|
|
|
query: String!
|
|
|
|
items: [Item!]!
|
|
|
|
}
|
|
|
|
|
2020-07-22 23:08:28 -07:00
|
|
|
# Cache for 1 week (unlikely to change)
|
|
|
|
type Color @cacheControl(maxAge: 604800) {
|
2020-04-25 03:42:05 -07:00
|
|
|
id: ID!
|
|
|
|
name: String!
|
2020-07-31 22:11:32 -07:00
|
|
|
isStandard: Boolean!
|
2020-04-25 03:42:05 -07:00
|
|
|
}
|
|
|
|
|
2020-07-22 23:08:28 -07:00
|
|
|
# Cache for 1 week (unlikely to change)
|
|
|
|
type Species @cacheControl(maxAge: 604800) {
|
2020-04-25 03:42:05 -07:00
|
|
|
id: ID!
|
|
|
|
name: String!
|
|
|
|
}
|
|
|
|
|
|
|
|
type SpeciesColorPair {
|
|
|
|
species: Species!
|
|
|
|
color: Color!
|
|
|
|
}
|
|
|
|
|
2020-04-25 06:50:34 -07:00
|
|
|
type Outfit {
|
2020-06-24 19:05:07 -07:00
|
|
|
id: ID!
|
|
|
|
name: String!
|
|
|
|
petAppearance: PetAppearance!
|
|
|
|
wornItems: [Item!]!
|
|
|
|
closetedItems: [Item!]!
|
|
|
|
|
|
|
|
species: Species! # to be deprecated? can use petAppearance? 🤔
|
|
|
|
color: Color! # to be deprecated? can use petAppearance? 🤔
|
|
|
|
pose: Pose! # to be deprecated? can use petAppearance? 🤔
|
|
|
|
items: [Item!]! # deprecated alias for wornItems
|
2020-04-25 06:50:34 -07:00
|
|
|
}
|
|
|
|
|
2020-04-22 11:51:36 -07:00
|
|
|
type Query {
|
2020-07-22 23:08:28 -07:00
|
|
|
allColors: [Color!]! @cacheControl(maxAge: 10800) # Cache for 3 hours (we might add more!)
|
|
|
|
allSpecies: [Species!]! @cacheControl(maxAge: 10800) # Cache for 3 hours (we might add more!)
|
2020-05-03 01:52:39 -07:00
|
|
|
allValidSpeciesColorPairs: [SpeciesColorPair!]! # deprecated
|
2020-07-31 22:31:28 -07:00
|
|
|
item(id: ID!): Item
|
2020-04-22 11:51:36 -07:00
|
|
|
items(ids: [ID!]!): [Item!]!
|
2020-04-25 01:55:48 -07:00
|
|
|
itemSearch(query: String!): ItemSearchResult!
|
|
|
|
itemSearchToFit(
|
|
|
|
query: String!
|
|
|
|
speciesId: ID!
|
|
|
|
colorId: ID!
|
|
|
|
offset: Int
|
|
|
|
limit: Int
|
|
|
|
): ItemSearchResult!
|
2020-05-23 12:47:06 -07:00
|
|
|
petAppearance(speciesId: ID!, colorId: ID!, pose: Pose!): PetAppearance
|
2020-07-22 23:08:28 -07:00
|
|
|
@cacheControl(maxAge: 604800) # Cache for 1 week (unlikely to change)
|
2020-05-02 16:49:57 -07:00
|
|
|
petAppearances(speciesId: ID!, colorId: ID!): [PetAppearance!]!
|
2020-07-22 23:08:28 -07:00
|
|
|
@cacheControl(maxAge: 10800) # Cache for 3 hours (we might add more!)
|
2020-06-24 19:05:07 -07:00
|
|
|
outfit(id: ID!): Outfit
|
|
|
|
|
2020-04-25 06:50:34 -07:00
|
|
|
petOnNeopetsDotCom(petName: String!): Outfit
|
2020-04-22 11:51:36 -07:00
|
|
|
}
|
2020-08-01 00:04:11 -07:00
|
|
|
|
|
|
|
type Mutation {
|
|
|
|
setManualSpecialColor(
|
|
|
|
itemId: ID!
|
|
|
|
colorId: ID
|
|
|
|
supportSecret: String!
|
|
|
|
): Item!
|
|
|
|
}
|
2020-04-22 11:51:36 -07:00
|
|
|
`;
|
|
|
|
|
|
|
|
const resolvers = {
|
|
|
|
Item: {
|
2020-07-02 14:33:47 -07:00
|
|
|
name: async ({ id, name }, _, { itemTranslationLoader }) => {
|
|
|
|
if (name) return name;
|
|
|
|
const translation = await itemTranslationLoader.load(id);
|
2020-04-22 11:51:36 -07:00
|
|
|
return translation.name;
|
|
|
|
},
|
2020-07-02 14:33:47 -07:00
|
|
|
description: async ({ id, description }, _, { itemTranslationLoader }) => {
|
|
|
|
if (description) return description;
|
|
|
|
const translation = await itemTranslationLoader.load(id);
|
2020-04-25 22:40:28 -07:00
|
|
|
return translation.description;
|
|
|
|
},
|
2020-07-02 14:33:47 -07:00
|
|
|
thumbnailUrl: async ({ id, thumbnailUrl }, _, { itemLoader }) => {
|
|
|
|
if (thumbnailUrl) return thumbnailUrl;
|
|
|
|
const item = await itemLoader.load(id);
|
|
|
|
return item.thumbnailUrl;
|
|
|
|
},
|
|
|
|
rarityIndex: async ({ id, rarityIndex }, _, { itemLoader }) => {
|
|
|
|
if (rarityIndex) return rarityIndex;
|
|
|
|
const item = await itemLoader.load(id);
|
|
|
|
return item.rarityIndex;
|
|
|
|
},
|
|
|
|
isNc: async ({ id, rarityIndex }, _, { itemLoader }) => {
|
2020-07-02 20:06:04 -07:00
|
|
|
if (rarityIndex != null) return rarityIndex === 500 || rarityIndex === 0;
|
|
|
|
const item = await itemLoader.load(id);
|
2020-07-02 14:33:47 -07:00
|
|
|
return item.rarityIndex === 500 || item.rarityIndex === 0;
|
|
|
|
},
|
2020-04-23 14:23:46 -07:00
|
|
|
appearanceOn: async (
|
2020-07-02 14:33:47 -07:00
|
|
|
{ id },
|
2020-04-23 14:23:46 -07:00
|
|
|
{ speciesId, colorId },
|
2020-07-02 14:33:47 -07:00
|
|
|
{ petTypeBySpeciesAndColorLoader, itemSwfAssetLoader, itemLoader }
|
2020-04-23 14:23:46 -07:00
|
|
|
) => {
|
2020-07-02 14:33:47 -07:00
|
|
|
const itemPromise = itemLoader.load(id);
|
2020-06-24 19:05:07 -07:00
|
|
|
const petType = await petTypeBySpeciesAndColorLoader.load({
|
2020-04-23 14:23:46 -07:00
|
|
|
speciesId: speciesId,
|
|
|
|
colorId: colorId,
|
2020-04-23 01:08:00 -07:00
|
|
|
});
|
2020-05-27 00:46:55 -07:00
|
|
|
const allSwfAssets = await itemSwfAssetLoader.load({
|
2020-07-02 14:33:47 -07:00
|
|
|
itemId: id,
|
2020-04-23 01:08:00 -07:00
|
|
|
bodyId: petType.bodyId,
|
|
|
|
});
|
2020-07-02 14:33:47 -07:00
|
|
|
|
2020-05-27 00:46:55 -07:00
|
|
|
if (allSwfAssets.length === 0) {
|
|
|
|
// If there's no assets at all, treat it as non-fitting: no appearance.
|
|
|
|
// (If there are assets but they're non-SWF, we'll treat this as
|
|
|
|
// fitting, but with an *empty* appearance.)
|
2020-04-25 04:38:55 -07:00
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
2020-05-27 00:46:55 -07:00
|
|
|
const swfAssets = allSwfAssets.filter((sa) => sa.url.endsWith(".swf"));
|
|
|
|
|
2020-04-23 14:44:06 -07:00
|
|
|
const restrictedZones = [];
|
2020-07-02 14:33:47 -07:00
|
|
|
const item = await itemPromise;
|
2020-04-23 14:44:06 -07:00
|
|
|
for (const [i, bit] of Array.from(item.zonesRestrict).entries()) {
|
|
|
|
if (bit === "1") {
|
|
|
|
const zone = { id: i + 1 };
|
|
|
|
restrictedZones.push(zone);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return { layers: swfAssets, restrictedZones };
|
2020-04-23 01:08:00 -07:00
|
|
|
},
|
2020-07-31 22:31:28 -07:00
|
|
|
manualSpecialColor: async ({ id }, _, { itemLoader }) => {
|
|
|
|
const item = await itemLoader.load(id);
|
|
|
|
return item.manualSpecialColorId != null
|
|
|
|
? { id: item.manualSpecialColorId }
|
|
|
|
: null;
|
|
|
|
},
|
2020-04-23 01:08:00 -07:00
|
|
|
},
|
2020-05-02 16:49:57 -07:00
|
|
|
PetAppearance: {
|
2020-06-24 19:05:07 -07:00
|
|
|
id: async ({ petStateId }, _, { petStateLoader, petTypeLoader }) => {
|
|
|
|
const petState = await petStateLoader.load(petStateId);
|
|
|
|
const petType = await petTypeLoader.load(petState.petTypeId);
|
2020-05-23 12:47:06 -07:00
|
|
|
const pose = getPoseFromPetState(petState);
|
2020-06-24 19:05:07 -07:00
|
|
|
return `${petType.speciesId}-${petType.colorId}-${pose}`;
|
2020-05-02 22:37:52 -07:00
|
|
|
},
|
2020-06-24 19:05:07 -07:00
|
|
|
color: async ({ petStateId }, _, { petStateLoader, petTypeLoader }) => {
|
|
|
|
const petState = await petStateLoader.load(petStateId);
|
|
|
|
const petType = await petTypeLoader.load(petState.petTypeId);
|
|
|
|
return { id: petType.colorId };
|
2020-05-02 20:48:32 -07:00
|
|
|
},
|
2020-06-24 19:05:07 -07:00
|
|
|
species: async ({ petStateId }, _, { petStateLoader, petTypeLoader }) => {
|
|
|
|
const petState = await petStateLoader.load(petStateId);
|
|
|
|
const petType = await petTypeLoader.load(petState.petTypeId);
|
|
|
|
return { id: petType.speciesId };
|
|
|
|
},
|
|
|
|
bodyId: async ({ petStateId }, _, { petStateLoader, petTypeLoader }) => {
|
|
|
|
const petState = await petStateLoader.load(petStateId);
|
|
|
|
const petType = await petTypeLoader.load(petState.petTypeId);
|
|
|
|
return petType.bodyId;
|
|
|
|
},
|
|
|
|
pose: async ({ petStateId }, _, { petStateLoader }) => {
|
|
|
|
const petState = await petStateLoader.load(petStateId);
|
|
|
|
return getPoseFromPetState(petState);
|
|
|
|
},
|
|
|
|
layers: async ({ petStateId }, _, { petSwfAssetLoader }) => {
|
|
|
|
const swfAssets = await petSwfAssetLoader.load(petStateId);
|
2020-05-02 16:49:57 -07:00
|
|
|
return swfAssets;
|
|
|
|
},
|
|
|
|
},
|
2020-04-23 14:23:46 -07:00
|
|
|
AppearanceLayer: {
|
2020-04-23 01:08:00 -07:00
|
|
|
zone: async (layer, _, { zoneLoader }) => {
|
|
|
|
const zone = await zoneLoader.load(layer.zoneId);
|
|
|
|
return zone;
|
|
|
|
},
|
|
|
|
imageUrl: (layer, { size }) => {
|
|
|
|
if (!layer.hasImage) {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
|
|
|
const sizeNum = size.split("_")[1];
|
|
|
|
|
|
|
|
const rid = layer.remoteId;
|
|
|
|
const paddedId = rid.padStart(12, "0");
|
|
|
|
const rid1 = paddedId.slice(0, 3);
|
|
|
|
const rid2 = paddedId.slice(3, 6);
|
|
|
|
const rid3 = paddedId.slice(6, 9);
|
|
|
|
const time = Number(new Date(layer.convertedAt));
|
|
|
|
|
2020-04-23 14:23:46 -07:00
|
|
|
return (
|
|
|
|
`https://impress-asset-images.s3.amazonaws.com/${layer.type}` +
|
2020-04-24 21:38:18 -07:00
|
|
|
`/${rid1}/${rid2}/${rid3}/${rid}/${sizeNum}x${sizeNum}.png?v2-${time}`
|
2020-04-23 14:23:46 -07:00
|
|
|
);
|
2020-04-23 01:08:00 -07:00
|
|
|
},
|
2020-05-23 11:32:05 -07:00
|
|
|
svgUrl: async (layer, _, { svgLogger }) => {
|
2020-05-11 21:19:34 -07:00
|
|
|
const manifest = await neopets.loadAssetManifest(layer.url);
|
|
|
|
if (!manifest) {
|
2020-05-23 11:32:05 -07:00
|
|
|
svgLogger.log("no-manifest");
|
2020-05-11 21:19:34 -07:00
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (manifest.assets.length !== 1) {
|
2020-05-23 11:32:05 -07:00
|
|
|
svgLogger.log(`wrong-asset-count:${manifest.assets.length}!=1`);
|
2020-05-11 21:19:34 -07:00
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
|
|
|
const asset = manifest.assets[0];
|
|
|
|
if (asset.format !== "vector") {
|
2020-05-23 11:32:05 -07:00
|
|
|
svgLogger.log(`wrong-asset-format:${asset.format}`);
|
2020-05-11 21:19:34 -07:00
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (asset.assetData.length !== 1) {
|
2020-05-23 11:32:05 -07:00
|
|
|
svgLogger.log(`wrong-assetData-length:${asset.assetData.length}!=1`);
|
2020-05-11 21:19:34 -07:00
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
2020-05-23 11:32:05 -07:00
|
|
|
svgLogger.log("success");
|
2020-05-11 21:19:34 -07:00
|
|
|
const assetDatum = asset.assetData[0];
|
|
|
|
const url = new URL(assetDatum.path, "http://images.neopets.com");
|
|
|
|
return url.toString();
|
|
|
|
},
|
2020-04-23 01:08:00 -07:00
|
|
|
},
|
|
|
|
Zone: {
|
2020-05-31 16:08:17 -07:00
|
|
|
depth: async ({ id }, _, { zoneLoader }) => {
|
|
|
|
// TODO: Should we extend this loader-in-field pattern elsewhere? I like
|
|
|
|
// that we avoid the fetch in cases where we only want the zone ID,
|
|
|
|
// but it adds complexity 🤔
|
|
|
|
const zone = await zoneLoader.load(id);
|
|
|
|
return zone.depth;
|
|
|
|
},
|
|
|
|
label: async ({ id }, _, { zoneTranslationLoader }) => {
|
|
|
|
const zoneTranslation = await zoneTranslationLoader.load(id);
|
2020-04-23 01:08:00 -07:00
|
|
|
return zoneTranslation.label;
|
|
|
|
},
|
2020-04-22 11:51:36 -07:00
|
|
|
},
|
2020-04-25 03:42:05 -07:00
|
|
|
Color: {
|
2020-06-24 19:05:07 -07:00
|
|
|
name: async ({ id }, _, { colorTranslationLoader }) => {
|
|
|
|
const colorTranslation = await colorTranslationLoader.load(id);
|
2020-04-25 04:33:05 -07:00
|
|
|
return capitalize(colorTranslation.name);
|
2020-04-25 03:42:05 -07:00
|
|
|
},
|
2020-07-31 22:11:32 -07:00
|
|
|
isStandard: async ({ id }, _, { colorLoader }) => {
|
|
|
|
const color = await colorLoader.load(id);
|
|
|
|
return color.standard ? true : false;
|
|
|
|
},
|
2020-04-25 03:42:05 -07:00
|
|
|
},
|
|
|
|
Species: {
|
2020-06-24 19:05:07 -07:00
|
|
|
name: async ({ id }, _, { speciesTranslationLoader }) => {
|
|
|
|
const speciesTranslation = await speciesTranslationLoader.load(id);
|
2020-04-25 04:33:05 -07:00
|
|
|
return capitalize(speciesTranslation.name);
|
2020-04-25 03:42:05 -07:00
|
|
|
},
|
|
|
|
},
|
2020-06-24 19:05:07 -07:00
|
|
|
Outfit: {
|
|
|
|
name: async ({ id }, _, { outfitLoader }) => {
|
|
|
|
const outfit = await outfitLoader.load(id);
|
|
|
|
return outfit.name;
|
|
|
|
},
|
|
|
|
petAppearance: async ({ id }, _, { outfitLoader }) => {
|
|
|
|
const outfit = await outfitLoader.load(id);
|
|
|
|
return { petStateId: outfit.petStateId };
|
|
|
|
},
|
|
|
|
wornItems: async ({ id }, _, { itemOutfitRelationshipsLoader }) => {
|
|
|
|
const relationships = await itemOutfitRelationshipsLoader.load(id);
|
|
|
|
return relationships
|
|
|
|
.filter((oir) => oir.isWorn)
|
|
|
|
.map((oir) => ({ id: oir.itemId }));
|
|
|
|
},
|
|
|
|
closetedItems: async ({ id }, _, { itemOutfitRelationshipsLoader }) => {
|
|
|
|
const relationships = await itemOutfitRelationshipsLoader.load(id);
|
|
|
|
return relationships
|
|
|
|
.filter((oir) => !oir.isWorn)
|
|
|
|
.map((oir) => ({ id: oir.itemId }));
|
|
|
|
},
|
|
|
|
},
|
2020-04-22 11:51:36 -07:00
|
|
|
Query: {
|
2020-07-31 22:11:32 -07:00
|
|
|
allColors: async (_, { ids }, { colorLoader }) => {
|
|
|
|
const allColors = await colorLoader.loadAll();
|
2020-04-25 03:42:05 -07:00
|
|
|
return allColors;
|
|
|
|
},
|
|
|
|
allSpecies: async (_, { ids }, { loadAllSpecies }) => {
|
|
|
|
const allSpecies = await loadAllSpecies();
|
|
|
|
return allSpecies;
|
|
|
|
},
|
|
|
|
allValidSpeciesColorPairs: async (_, __, { loadAllPetTypes }) => {
|
|
|
|
const allPetTypes = await loadAllPetTypes();
|
|
|
|
const allPairs = allPetTypes.map((pt) => ({
|
|
|
|
color: { id: pt.colorId },
|
|
|
|
species: { id: pt.speciesId },
|
|
|
|
}));
|
|
|
|
return allPairs;
|
|
|
|
},
|
2020-07-31 22:31:28 -07:00
|
|
|
item: (_, { id }) => ({ id }),
|
2020-07-02 20:06:04 -07:00
|
|
|
items: (_, { ids }) => {
|
2020-07-22 23:08:28 -07:00
|
|
|
return ids.map((id) => ({ id }));
|
2020-04-24 21:17:03 -07:00
|
|
|
},
|
|
|
|
itemSearch: async (_, { query }, { itemSearchLoader }) => {
|
2020-05-31 15:52:54 -07:00
|
|
|
const items = await itemSearchLoader.load(query.trim());
|
2020-04-25 01:55:48 -07:00
|
|
|
return { query, items };
|
2020-04-25 00:43:01 -07:00
|
|
|
},
|
|
|
|
itemSearchToFit: async (
|
|
|
|
_,
|
2020-04-25 01:55:48 -07:00
|
|
|
{ query, speciesId, colorId, offset, limit },
|
2020-06-24 19:05:07 -07:00
|
|
|
{ petTypeBySpeciesAndColorLoader, itemSearchToFitLoader }
|
2020-04-25 00:43:01 -07:00
|
|
|
) => {
|
2020-06-24 19:05:07 -07:00
|
|
|
const petType = await petTypeBySpeciesAndColorLoader.load({
|
|
|
|
speciesId,
|
|
|
|
colorId,
|
|
|
|
});
|
2020-04-25 00:43:01 -07:00
|
|
|
const { bodyId } = petType;
|
2020-04-25 01:55:48 -07:00
|
|
|
const items = await itemSearchToFitLoader.load({
|
2020-05-31 15:52:54 -07:00
|
|
|
query: query.trim(),
|
2020-04-25 01:55:48 -07:00
|
|
|
bodyId,
|
|
|
|
offset,
|
|
|
|
limit,
|
|
|
|
});
|
|
|
|
return { query, items };
|
2020-04-23 01:08:00 -07:00
|
|
|
},
|
2020-04-23 14:23:46 -07:00
|
|
|
petAppearance: async (
|
|
|
|
_,
|
2020-05-23 12:47:06 -07:00
|
|
|
{ speciesId, colorId, pose },
|
2020-06-24 19:05:07 -07:00
|
|
|
{ petTypeBySpeciesAndColorLoader, petStatesForPetTypeLoader }
|
2020-04-23 14:23:46 -07:00
|
|
|
) => {
|
2020-06-24 19:05:07 -07:00
|
|
|
const petType = await petTypeBySpeciesAndColorLoader.load({
|
2020-04-23 14:23:46 -07:00
|
|
|
speciesId,
|
|
|
|
colorId,
|
|
|
|
});
|
2020-05-02 22:32:08 -07:00
|
|
|
|
2020-06-24 19:05:07 -07:00
|
|
|
const petStates = await petStatesForPetTypeLoader.load(petType.id);
|
2020-05-02 22:32:08 -07:00
|
|
|
// TODO: This could be optimized into the query condition 🤔
|
2020-05-23 12:47:06 -07:00
|
|
|
const petState = petStates.find((ps) => getPoseFromPetState(ps) === pose);
|
2020-05-02 22:32:08 -07:00
|
|
|
if (!petState) {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
2020-06-24 19:05:07 -07:00
|
|
|
return { petStateId: petState.id };
|
2020-05-02 16:49:57 -07:00
|
|
|
},
|
|
|
|
petAppearances: async (
|
|
|
|
_,
|
|
|
|
{ speciesId, colorId },
|
2020-06-24 19:05:07 -07:00
|
|
|
{ petTypeBySpeciesAndColorLoader, petStatesForPetTypeLoader }
|
2020-05-02 16:49:57 -07:00
|
|
|
) => {
|
2020-06-24 19:05:07 -07:00
|
|
|
const petType = await petTypeBySpeciesAndColorLoader.load({
|
2020-05-02 16:49:57 -07:00
|
|
|
speciesId,
|
|
|
|
colorId,
|
|
|
|
});
|
2020-06-24 19:05:07 -07:00
|
|
|
const petStates = await petStatesForPetTypeLoader.load(petType.id);
|
2020-07-31 22:11:32 -07:00
|
|
|
petStates.sort((a, b) => a.id - b.id);
|
2020-06-24 19:05:07 -07:00
|
|
|
return petStates.map((petState) => ({ petStateId: petState.id }));
|
2020-04-23 14:23:46 -07:00
|
|
|
},
|
2020-06-24 19:05:07 -07:00
|
|
|
outfit: (_, { id }) => ({ id }),
|
2020-04-25 06:50:34 -07:00
|
|
|
petOnNeopetsDotCom: async (_, { petName }) => {
|
2020-05-23 13:55:59 -07:00
|
|
|
const [petMetaData, customPetData] = await Promise.all([
|
|
|
|
neopets.loadPetMetaData(petName),
|
|
|
|
neopets.loadCustomPetData(petName),
|
|
|
|
]);
|
2020-04-25 06:50:34 -07:00
|
|
|
const outfit = {
|
2020-06-24 19:05:07 -07:00
|
|
|
// TODO: This isn't a fully-working Outfit object. It works for the
|
|
|
|
// client as currently implemented, but we'll probably want to
|
|
|
|
// move the client and this onto our more generic fields!
|
2020-05-23 13:55:59 -07:00
|
|
|
species: { id: customPetData.custom_pet.species_id },
|
|
|
|
color: { id: customPetData.custom_pet.color_id },
|
|
|
|
pose: getPoseFromPetData(petMetaData, customPetData),
|
|
|
|
items: Object.values(customPetData.object_info_registry).map((o) => ({
|
2020-04-25 06:50:34 -07:00
|
|
|
id: o.obj_info_id,
|
2020-07-02 14:33:47 -07:00
|
|
|
name: o.name,
|
|
|
|
description: o.description,
|
|
|
|
thumbnailUrl: o.thumbnail_url,
|
|
|
|
rarityIndex: o.rarity_index,
|
2020-04-25 06:50:34 -07:00
|
|
|
})),
|
|
|
|
};
|
|
|
|
return outfit;
|
|
|
|
},
|
2020-04-22 11:51:36 -07:00
|
|
|
},
|
2020-08-01 00:04:11 -07:00
|
|
|
Mutation: {
|
|
|
|
setManualSpecialColor: async (
|
|
|
|
_,
|
|
|
|
{ itemId, colorId, supportSecret },
|
|
|
|
{ db }
|
|
|
|
) => {
|
|
|
|
if (supportSecret !== process.env["SUPPORT_SECRET"]) {
|
|
|
|
throw new Error(`Support secret is incorrect. Try setting up again?`);
|
|
|
|
}
|
|
|
|
|
|
|
|
const [
|
|
|
|
result,
|
|
|
|
] = await db.execute(
|
|
|
|
`UPDATE items SET manual_special_color_id = ? WHERE id = ? LIMIT 1`,
|
|
|
|
[colorId, itemId]
|
|
|
|
);
|
|
|
|
|
|
|
|
if (result.affectedRows !== 1) {
|
|
|
|
throw new Error(
|
|
|
|
`Expected to affect 1 item, but affected ${result.affectedRows}`
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
return { id: itemId };
|
|
|
|
},
|
|
|
|
},
|
2020-04-22 11:51:36 -07:00
|
|
|
};
|
|
|
|
|
2020-05-23 11:32:05 -07:00
|
|
|
let lastSvgLogger = null;
|
|
|
|
const svgLogging = {
|
|
|
|
requestDidStart() {
|
|
|
|
return {
|
|
|
|
willSendResponse({ operationName }) {
|
|
|
|
const logEntries = lastSvgLogger.entries;
|
|
|
|
if (logEntries.length === 0) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
console.log(`[svgLogger] Operation: ${operationName}`);
|
|
|
|
|
|
|
|
const logEntryCounts = {};
|
|
|
|
for (const logEntry of logEntries) {
|
|
|
|
logEntryCounts[logEntry] = (logEntryCounts[logEntry] || 0) + 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
const logEntriesSortedByCount = Object.entries(logEntryCounts).sort(
|
|
|
|
(a, b) => b[1] - a[1]
|
|
|
|
);
|
|
|
|
for (const [logEntry, count] of logEntriesSortedByCount) {
|
|
|
|
console.log(`[svgLogger] - ${logEntry}: ${count}`);
|
|
|
|
}
|
|
|
|
},
|
|
|
|
};
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2020-04-22 13:03:32 -07:00
|
|
|
const config = {
|
2020-04-22 11:51:36 -07:00
|
|
|
typeDefs,
|
|
|
|
resolvers,
|
|
|
|
context: async () => {
|
|
|
|
const db = await connectToDb();
|
2020-05-23 11:32:05 -07:00
|
|
|
|
|
|
|
const svgLogger = {
|
|
|
|
entries: [],
|
|
|
|
log(entry) {
|
|
|
|
this.entries.push(entry);
|
|
|
|
},
|
|
|
|
};
|
|
|
|
lastSvgLogger = svgLogger;
|
|
|
|
|
2020-04-22 12:00:52 -07:00
|
|
|
return {
|
2020-05-23 11:32:05 -07:00
|
|
|
svgLogger,
|
2020-08-01 00:04:11 -07:00
|
|
|
db,
|
2020-04-23 14:23:46 -07:00
|
|
|
...buildLoaders(db),
|
2020-04-22 12:00:52 -07:00
|
|
|
};
|
2020-04-22 11:51:36 -07:00
|
|
|
},
|
2020-04-23 01:09:17 -07:00
|
|
|
|
2020-05-23 11:32:05 -07:00
|
|
|
plugins: [svgLogging],
|
|
|
|
|
2020-04-23 01:09:17 -07:00
|
|
|
// Enable Playground in production :)
|
|
|
|
introspection: true,
|
2020-04-23 01:12:52 -07:00
|
|
|
playground: {
|
|
|
|
endpoint: "/api/graphql",
|
|
|
|
},
|
2020-04-22 13:03:32 -07:00
|
|
|
};
|
2020-04-22 11:51:36 -07:00
|
|
|
|
|
|
|
if (require.main === module) {
|
2020-04-22 13:03:32 -07:00
|
|
|
const { ApolloServer } = require("apollo-server");
|
|
|
|
const server = new ApolloServer(config);
|
2020-04-22 11:51:36 -07:00
|
|
|
server.listen().then(({ url }) => {
|
|
|
|
console.log(`🚀 Server ready at ${url}`);
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2020-04-22 13:03:32 -07:00
|
|
|
module.exports = { config };
|