import { toastSuccess } from '$lib/Toasts';
import {
Client,
type AnyVariables,
type OperationResult,
type OperationResultSource
} from '@urql/svelte';
import { isError, isSuccess, type RequiredName } from './Utils';
import * as gql from './graphql';
export type DeleteMutation = (client: Client, args: { ids: number | number[] }) => Promise<unknown>;
const comicTypes = ['Comic'];
const comicUpsertTypes = comicTypes.concat([
'Artist',
'Character',
'Circle',
'Namespace',
'Collection',
'Tag',
'World'
]);
function handleResult<D, I extends AnyVariables>(result: OperationResult<D, I>): Promise<D> {
return new Promise((resolve, reject) => {
if (result.error) {
return reject(`${result.error.name}: ${result.error.message}`);
}
if (!result.data) {
return reject('Mutation resolved, but result contains no data.');
}
const obj = Object.values(result.data)[0];
if (isError(obj)) {
reject(obj.message);
} else if (isSuccess(obj)) {
toastSuccess(obj.message);
resolve(result.data);
}
reject('This should not happen.');
});
}
async function handleMutation<D, V extends AnyVariables>(
mutation: OperationResultSource<OperationResult<D, V>>
) {
return await mutation.toPromise().then(handleResult);
}
export async function addComic(client: Client, args: gql.AddComicMutationVariables) {
return await handleMutation(
client.mutation(gql.AddComicDocument, args, {
additionalTypenames: comicTypes.concat('Archive', 'Page')
})
);
}
export async function updateComics(client: Client, args: gql.UpdateComicsMutationVariables) {
return await handleMutation(
client.mutation(gql.UpdateComicsDocument, args, {
additionalTypenames: comicTypes
})
);
}
export async function upsertComics(client: Client, args: gql.UpsertComicsMutationVariables) {
return await handleMutation(
client.mutation(gql.UpsertComicsDocument, args, {
additionalTypenames: comicUpsertTypes
})
);
}
export async function updateArchives(client: Client, args: gql.UpdateArchivesMutationVariables) {
return await handleMutation(
client.mutation(gql.UpdateArchivesDocument, args, {
additionalTypenames: ['Archive']
})
);
}
export async function deleteArchives(client: Client, args: gql.DeleteArchivesMutationVariables) {
return await handleMutation(
client.mutation(gql.DeleteArchivesDocument, args, {
additionalTypenames: comicTypes.concat('Archive')
})
);
}
export async function deleteComics(client: Client, args: gql.DeleteComicsMutationVariables) {
return await handleMutation(
client.mutation(gql.DeleteComicsDocument, args, { additionalTypenames: comicTypes })
);
}
export async function addArtist(client: Client, args: gql.AddArtistMutationVariables) {
return await handleMutation(
client.mutation(gql.AddArtistDocument, args, { additionalTypenames: ['ArtistFilterResult'] })
);
}
export async function updateArtists(client: Client, args: gql.UpdateArtistsMutationVariables) {
return await handleMutation(
client.mutation(gql.UpdateArtistsDocument, args, { additionalTypenames: ['Artist'] })
);
}
export async function deleteArtists(client: Client, args: gql.DeleteArtistsMutationVariables) {
return await handleMutation(
client.mutation(gql.DeleteArtistsDocument, args, {
additionalTypenames: ['Artist']
})
);
}
export async function addCharacter(client: Client, args: gql.AddCharacterMutationVariables) {
return await handleMutation(
client.mutation(gql.AddCharacterDocument, args, {
additionalTypenames: ['CharacterFilterResult']
})
);
}
export async function updateCharacters(
client: Client,
args: gql.UpdateCharactersMutationVariables
) {
return await handleMutation(
client.mutation(gql.UpdateCharactersDocument, args, { additionalTypenames: ['Character'] })
);
}
export async function deleteCharacters(
client: Client,
args: gql.DeleteCharactersMutationVariables
) {
return await handleMutation(
client.mutation(gql.DeleteCharactersDocument, args, {
additionalTypenames: ['Character']
})
);
}
export async function addCircle(client: Client, args: gql.AddCircleMutationVariables) {
return await handleMutation(
client.mutation(gql.AddCircleDocument, args, { additionalTypenames: ['CircleFilterResult'] })
);
}
export async function updateCircles(client: Client, args: gql.UpdateCirclesMutationVariables) {
return await handleMutation(
client.mutation(gql.UpdateCirclesDocument, args, { additionalTypenames: ['Circle'] })
);
}
export async function deleteCircles(client: Client, args: gql.DeleteCirclesMutationVariables) {
return await handleMutation(
client.mutation(gql.DeleteCirclesDocument, args, {
additionalTypenames: ['Circle']
})
);
}
export async function addNamespace(client: Client, args: gql.AddNamespaceMutationVariables) {
return await handleMutation(
client.mutation(gql.AddNamespaceDocument, args, {
additionalTypenames: ['NamespaceFilterResult', 'ComicTagFilterResult']
})
);
}
export async function updateNamespaces(
client: Client,
args: gql.UpdateNamespacesMutationVariables
) {
return await handleMutation(
client.mutation(gql.UpdateNamespacesDocument, args, {
additionalTypenames: ['Namespace', 'ComicTag']
})
);
}
export async function deleteNamespaces(
client: Client,
args: gql.DeleteNamespacesMutationVariables
) {
return await handleMutation(
client.mutation(gql.DeleteNamespacesDocument, args, {
additionalTypenames: ['NamespaceFilterResult', 'ComicTag']
})
);
}
export async function addTag(client: Client, args: gql.AddTagMutationVariables) {
return await handleMutation(
client.mutation(gql.AddTagDocument, args, {
additionalTypenames: ['TagFilterResult', 'ComicTagFilterResult']
})
);
}
export async function updateTags(client: Client, args: gql.UpdateTagsMutationVariables) {
return await handleMutation(
client.mutation(gql.UpdateTagsDocument, args, {
additionalTypenames: ['Tag', 'ComicTag']
})
);
}
export async function deleteTags(client: Client, args: gql.DeleteTagsMutationVariables) {
return await handleMutation(
client.mutation(gql.DeleteTagsDocument, args, {
additionalTypenames: ['TagFilterResult', 'ComicTag']
})
);
}
export async function addWorld(client: Client, args: gql.AddWorldMutationVariables) {
return await handleMutation(
client.mutation(gql.AddWorldDocument, args, { additionalTypenames: ['WorldFilterResult'] })
);
}
export async function updateWorlds(client: Client, args: gql.UpdateWorldsMutationVariables) {
return await handleMutation(
client.mutation(gql.UpdateWorldsDocument, args, { additionalTypenames: ['World'] })
);
}
export async function deleteWorlds(client: Client, args: gql.DeleteWorldsMutationVariables) {
return await handleMutation(
client.mutation(gql.DeleteWorldsDocument, args, { additionalTypenames: ['World'] })
);
}
export type ArtistInput = RequiredName<gql.UpdateArtistInput>;
export type CharacterInput = RequiredName<gql.UpdateCharacterInput>;
export type CircleInput = RequiredName<gql.UpdateCircleInput>;
export type NamespaceInput = RequiredName<gql.UpdateNamespaceInput>;
export type TagInput = RequiredName<gql.UpdateTagInput>;
export type WorldInput = RequiredName<gql.UpdateWorldInput>;