@contember/client 0.0.0

package/src/crudQueryBuilder/WriteOneRelationBuilder.ts

@@ -0,0 +1,101 @@
+import type { Input } from '@contember/schema'
+import type { GraphQlLiteral } from '../graphQlBuilder'
+import type { WriteOperation, WriteRelationOps } from './types'
+import { WriteDataBuilder } from './WriteDataBuilder'
+
+class WriteOneRelationBuilder<
+	Op extends WriteOperation.ContentfulOperation,
+	Allowed extends WriteRelationOps[Op['op']] = WriteRelationOps[Op['op']],
+	D extends WriteOneRelationBuilder.DataFormat[Op['op']] | undefined = WriteOneRelationBuilder.DataFormat[Op['op']],
+> {
+	protected constructor(public readonly data: D = undefined as D) {}
+
+	public static instantiate<
+		Op extends WriteOperation.ContentfulOperation,
+		Allowed extends WriteRelationOps[Op['op']] = WriteRelationOps[Op['op']],
+		D extends WriteOneRelationBuilder.DataFormat[Op['op']] | undefined = WriteOneRelationBuilder.DataFormat[Op['op']],
+	>(data: D = undefined as D): WriteOneRelationBuilder.Builder<Op, Allowed, D> {
+		return new WriteOneRelationBuilder<Op, Allowed, D>(data)
+	}
+
+	public static instantiateFromFactory<
+		Op extends WriteOperation.ContentfulOperation,
+		Allowed extends WriteRelationOps[Op['op']] = WriteRelationOps[Op['op']],
+		D extends WriteOneRelationBuilder.DataFormat[Op['op']] | undefined = WriteOneRelationBuilder.DataFormat[Op['op']],
+	>(builder: WriteOneRelationBuilder.BuilderFactory<Op, Allowed, D>): WriteOneRelationBuilder.Builder<Op, never, D> {
+		if (typeof builder === 'function') {
+			return builder(WriteOneRelationBuilder.instantiate())
+		}
+		if (builder && 'data' in builder!) {
+			return WriteOneRelationBuilder.instantiate(builder.data)
+		}
+		return WriteOneRelationBuilder.instantiate(builder)
+	}
+
+	public create(data: WriteDataBuilder.DataLike<WriteOperation.Create>) {
+		const resolvedData = WriteDataBuilder.resolveData(data)
+		return resolvedData === undefined
+			? this
+			: WriteOneRelationBuilder.instantiate<Op, never>({
+					create: resolvedData,
+			  })
+	}
+
+	public connect(where: Input.UniqueWhere<GraphQlLiteral>) {
+		return WriteOneRelationBuilder.instantiate<Op, never>({ connect: where })
+	}
+
+	public delete() {
+		return WriteOneRelationBuilder.instantiate<WriteOperation.Update, never>({ delete: true })
+	}
+
+	public disconnect() {
+		return WriteOneRelationBuilder.instantiate<WriteOperation.Update, never>({ disconnect: true })
+	}
+
+	public update(data: WriteDataBuilder.DataLike<WriteOperation.Update>) {
+		const resolvedData = WriteDataBuilder.resolveData(data)
+		return resolvedData === undefined ? this : new WriteOneRelationBuilder({ update: resolvedData })
+	}
+
+	public upsert(
+		update: WriteDataBuilder.DataLike<WriteOperation.Update>,
+		create: WriteDataBuilder.DataLike<WriteOperation.Create>,
+	) {
+		const resolvedCreate = WriteDataBuilder.resolveData(create)
+		const resolvedUpdate = WriteDataBuilder.resolveData(update)
+
+		return resolvedUpdate === undefined && resolvedCreate === undefined
+			? this
+			: WriteOneRelationBuilder.instantiate<WriteOperation.Update, never>({
+					upsert: {
+						update: resolvedUpdate || {},
+						create: resolvedCreate || {},
+					},
+			  })
+	}
+}
+
+namespace WriteOneRelationBuilder {
+	export interface DataFormat {
+		create: Input.CreateOneRelationInput<GraphQlLiteral>
+		update: Input.UpdateOneRelationInput<GraphQlLiteral>
+	}
+
+	export type Builder<
+		Op extends WriteOperation.ContentfulOperation,
+		Allowed extends WriteRelationOps[Op['op']] = WriteRelationOps[Op['op']],
+		D extends WriteOneRelationBuilder.DataFormat[Op['op']] | undefined = WriteOneRelationBuilder.DataFormat[Op['op']],
+	> = Omit<
+		WriteOneRelationBuilder<Op, Allowed, D>,
+		Exclude<WriteRelationOps[WriteOperation.ContentfulOperation['op']], Allowed>
+	>
+
+	export type BuilderFactory<
+		Op extends WriteOperation.ContentfulOperation,
+		Allowed extends WriteRelationOps[Op['op']] = WriteRelationOps[Op['op']],
+		D extends WriteOneRelationBuilder.DataFormat[Op['op']] | undefined = WriteOneRelationBuilder.DataFormat[Op['op']],
+	> = D | Builder<Op, never, D> | ((builder: Builder<Op, Allowed, D>) => Builder<Op, never, D>)
+}
+
+export { WriteOneRelationBuilder }

package/src/crudQueryBuilder/index.ts

@@ -0,0 +1,7 @@
+export * from './CrudQueryBuilder'
+export * from './ReadBuilder'
+export * from './types'
+export * from './WriteBuilder'
+export * from './WriteDataBuilder'
+export * from './WriteManyRelationBuilder'
+export * from './WriteOneRelationBuilder'

package/src/crudQueryBuilder/types.ts

@@ -0,0 +1,73 @@
+import { GraphQlLiteral } from '../graphQlBuilder'
+
+export type Mutations = 'create' | 'update' | 'delete'
+
+export type Queries = 'get' | 'list' | 'paginate'
+
+export type GetQueryArguments = 'by'
+
+export type ListQueryArguments = 'filter' | 'orderBy' | 'offset' | 'limit'
+
+export type PaginateQueryArguments = 'filter' | 'orderBy' | 'skip' | 'first'
+
+export type CreateMutationArguments = 'data'
+
+export type UpdateMutationArguments = 'data' | 'by'
+
+export type DeleteMutationArguments = 'by'
+
+export type ReductionArguments = 'filter' | 'by'
+
+export type HasOneArguments = 'filter'
+
+export type HasManyArguments = 'filter' | 'orderBy' | 'offset' | 'limit'
+
+export type UpdateMutationFields = 'ok' | 'validation' | 'errors' | 'errorMessage' | 'node'
+
+export type CreateMutationFields = 'ok' | 'validation' | 'errors' | 'errorMessage' | 'node'
+
+export type DeleteMutationFields = 'ok' | 'node' | 'errors' | 'errorMessage'
+
+export type WriteArguments = CreateMutationArguments | UpdateMutationArguments | DeleteMutationArguments
+
+export type WriteFields = UpdateMutationFields | CreateMutationFields
+
+export type ReadArguments =
+	| GetQueryArguments
+	| ListQueryArguments
+	| PaginateQueryArguments
+	| HasOneArguments
+	| HasManyArguments
+
+export interface WriteRelationOps {
+	create: 'create' | 'connect'
+	update: 'create' | 'connect' | 'delete' | 'disconnect' | 'update' | 'upsert'
+}
+
+export type OrderDirection = GraphQlLiteral<'asc'> | GraphQlLiteral<'desc'>
+
+// TODO Silly enums because TS does not support enum extension 🙄
+// https://github.com/Microsoft/TypeScript/issues/17592
+export namespace WriteOperation {
+	export interface Operation {
+		op: 'create' | 'update' | 'delete'
+	}
+	export abstract class Operation implements Operation {}
+
+	export interface ContentfulOperation {
+		op: 'create' | 'update'
+	}
+	export abstract class ContentfulOperation extends Operation implements ContentfulOperation {}
+
+	export class Update extends ContentfulOperation {
+		override readonly op = 'update' as const
+	}
+
+	export class Create extends ContentfulOperation {
+		override readonly op = 'create' as const
+	}
+
+	export class Delete extends Operation {
+		override readonly op = 'delete' as const
+	}
+}

package/src/graphQlBuilder/GraphQlBuilderError.ts

@@ -0,0 +1 @@
+export class GraphQlBuilderError extends Error {}

package/src/graphQlBuilder/GraphQlLiteral.ts

@@ -0,0 +1,7 @@
+export class GraphQlLiteral<Value extends string = string> {
+	constructor(public readonly value: Value) {}
+
+	public toString() {
+		return `Literal(${this.value})`
+	}
+}

package/src/graphQlBuilder/ObjectBuilder.ts

@@ -0,0 +1,87 @@
+export class ObjectBuilder {
+	constructor(
+		public readonly fields: string[] = [],
+		public readonly objects: { [name: string]: ObjectBuilder } = {},
+		public readonly args: { [name: string]: any } = {},
+		public readonly fragmentApplications: string[] = [],
+		public readonly inlineFragments: { [typeName: string]: ObjectBuilder } = {},
+		public readonly objectName?: string,
+	) {}
+
+	public argument(name: string, value: any): ObjectBuilder {
+		return new ObjectBuilder(
+			this.fields,
+			this.objects,
+			{ ...this.args, [name]: value },
+			this.fragmentApplications,
+			this.inlineFragments,
+			this.objectName,
+		)
+	}
+
+	public name(name: string): ObjectBuilder {
+		return new ObjectBuilder(
+			this.fields,
+			this.objects,
+			this.args,
+			this.fragmentApplications,
+			this.inlineFragments,
+			name,
+		)
+	}
+
+	public field(name: string): ObjectBuilder {
+		return new ObjectBuilder(
+			[...this.fields, name],
+			this.objects,
+			this.args,
+			this.fragmentApplications,
+			this.inlineFragments,
+			this.objectName,
+		)
+	}
+
+	public object(name: string, builder: ((builder: ObjectBuilder) => ObjectBuilder) | ObjectBuilder): ObjectBuilder {
+		if (!(builder instanceof ObjectBuilder)) {
+			builder = builder(new ObjectBuilder())
+		}
+
+		return new ObjectBuilder(
+			this.fields,
+			{ ...this.objects, [name]: builder },
+			this.args,
+			this.fragmentApplications,
+			this.inlineFragments,
+			this.objectName,
+		)
+	}
+
+	public inlineFragment(
+		typeName: string,
+		builder: ((builder: ObjectBuilder) => ObjectBuilder) | ObjectBuilder,
+	): ObjectBuilder {
+		if (!(builder instanceof ObjectBuilder)) {
+			builder = builder(new ObjectBuilder())
+		}
+
+		return new ObjectBuilder(
+			this.fields,
+			this.objects,
+			this.args,
+			this.fragmentApplications,
+			{ ...this.inlineFragments, [typeName]: builder },
+			this.objectName,
+		)
+	}
+
+	public applyFragment(fragmentName: string): ObjectBuilder {
+		return new ObjectBuilder(
+			this.fields,
+			this.objects,
+			this.args,
+			[...this.fragmentApplications, fragmentName],
+			this.inlineFragments,
+			this.objectName,
+		)
+	}
+}

package/src/graphQlBuilder/QueryBuilder.ts

@@ -0,0 +1,34 @@
+import type { GraphQlLiteral } from './GraphQlLiteral'
+import { QueryCompiler } from './QueryCompiler'
+import { RootObjectBuilder } from './RootObjectBuilder'
+
+class QueryBuilder {
+	query(builder: ((builder: RootObjectBuilder) => RootObjectBuilder) | RootObjectBuilder): string {
+		if (!(builder instanceof RootObjectBuilder)) {
+			builder = builder(new RootObjectBuilder())
+		}
+		const compiler = new QueryCompiler('query', builder)
+		return compiler.create()
+	}
+
+	mutation(builder: ((builder: RootObjectBuilder) => RootObjectBuilder) | RootObjectBuilder): string {
+		if (!(builder instanceof RootObjectBuilder)) {
+			builder = builder(new RootObjectBuilder())
+		}
+		const compiler = new QueryCompiler('mutation', builder)
+		return compiler.create()
+	}
+}
+
+namespace QueryBuilder {
+	export interface Object {
+		[key: string]: Value
+	}
+
+	export interface List extends Array<Value> {}
+
+	export type AtomicValue = string | null | number | boolean | GraphQlLiteral
+	export type Value = AtomicValue | QueryBuilder.Object | List
+}
+
+export { QueryBuilder }

package/src/graphQlBuilder/QueryCompiler.ts

@@ -0,0 +1,115 @@
+import { GraphQlLiteral } from './GraphQlLiteral'
+import type { ObjectBuilder } from './ObjectBuilder'
+import type { RootObjectBuilder } from './RootObjectBuilder'
+
+export class QueryCompiler {
+	constructor(private operation: 'query' | 'mutation', private builder: RootObjectBuilder) {}
+
+	public create(): string {
+		const rootObjects = this.formatRootObjects(this.builder.objects)
+		const fragmentDefinitions = this.formatFragmentDefinitions(this.builder.fragmentDefinitions)
+
+		return `${this.operation} {\n${rootObjects}\n}${fragmentDefinitions ? `\n${fragmentDefinitions}` : ''}`
+	}
+
+	private formatFragmentDefinitions(fragments: RootObjectBuilder['fragmentDefinitions']): string {
+		const lines: string[] = []
+
+		for (const name in fragments) {
+			const object = fragments[name]
+
+			lines.push(`fragment ${name} on ${object.objectName!} {`)
+			lines.push(...this.formatObjectBody(object))
+			lines.push('}')
+		}
+
+		return lines.join('\n')
+	}
+
+	private formatRootObjects(objects: RootObjectBuilder['objects']): string {
+		const lines: string[] = []
+
+		for (const alias in objects) {
+			lines.push(...this.formatObject(alias, objects[alias]).map(val => `\t${val}`))
+		}
+
+		return lines.join('\n')
+	}
+
+	private formatObject(alias: string, builder: ObjectBuilder): string[] {
+		const result = []
+
+		result.push(`${alias}${builder.objectName ? `: ${builder.objectName}` : ''}${this.formatArgs(builder.args, 0)} {`)
+
+		result.push(...this.formatObjectBody(builder))
+
+		result.push('}')
+
+		return result
+	}
+
+	private formatObjectBody(builder: ObjectBuilder): string[] {
+		const result = ['__typename']
+		for (const fieldName of builder.fields) {
+			result.push(fieldName)
+		}
+		for (const fragmentName of builder.fragmentApplications) {
+			result.push(`... ${fragmentName}`)
+		}
+		for (const typeName in builder.inlineFragments) {
+			const fragment = builder.inlineFragments[typeName]
+			result.push(`... on ${typeName} {`, ...this.formatObjectBody(fragment), '}')
+		}
+		for (const alias in builder.objects) {
+			result.push(...this.formatObject(alias, builder.objects[alias]))
+		}
+		return result.map(val => `\t${val}`)
+	}
+
+	private formatArgs(args: any, level: number): string {
+		if (args === null) {
+			return 'null'
+		}
+
+		if (typeof args === 'number') {
+			return args.toString()
+		}
+
+		if (typeof args === 'boolean') {
+			return args ? 'true' : 'false'
+		}
+		if (typeof args === 'string') {
+			return JSON.stringify(args)
+		}
+
+		if (Array.isArray(args)) {
+			const vals = args.map(val => this.formatArgs(val, level + 1))
+			return `[${vals.join(', ')}]`
+		}
+		if (args instanceof GraphQlLiteral) {
+			return args.value
+		}
+
+		if (typeof args === 'object') {
+			let result = ''
+			for (let key in args) {
+				const argValue = args[key]
+				if (argValue === undefined) {
+					continue
+				}
+				result += `${key}: ${this.formatArgs(argValue, level + 1)}, `
+			}
+			if (result.length > 0) {
+				result = result.substring(0, result.length - 2)
+			}
+			if (level > 0) {
+				return `{${result}}`
+			} else if (result.length > 0) {
+				return `(${result})`
+			}
+			return ''
+		}
+
+		throw new Error(typeof args)
+	}
+}

package/src/graphQlBuilder/RootObjectBuilder.ts

@@ -0,0 +1,36 @@
+import { isEmptyObject } from '../utils'
+import { GraphQlBuilderError } from './GraphQlBuilderError'
+import { ObjectBuilder } from './ObjectBuilder'
+
+export class RootObjectBuilder {
+	constructor(
+		public readonly objects: { [name: string]: ObjectBuilder } = {},
+		public readonly fragmentDefinitions: { [name: string]: ObjectBuilder } = {},
+	) {}
+
+	public fragment(
+		name: string,
+		builder: ((builder: ObjectBuilder) => ObjectBuilder) | ObjectBuilder,
+	): RootObjectBuilder {
+		if (!(builder instanceof ObjectBuilder)) {
+			builder = builder(new ObjectBuilder())
+		}
+
+		if (!isEmptyObject(builder.args)) {
+			throw new GraphQlBuilderError(`Cannot supply args to Graph QL fragments!`)
+		}
+		if (!builder.objectName) {
+			throw new GraphQlBuilderError(`Object names are mandatory for Graph QL fragments!`)
+		}
+
+		return new RootObjectBuilder(this.objects, { ...this.fragmentDefinitions, [name]: builder })
+	}
+
+	public object(name: string, builder: ((builder: ObjectBuilder) => ObjectBuilder) | ObjectBuilder): RootObjectBuilder {
+		if (!(builder instanceof ObjectBuilder)) {
+			builder = builder(new ObjectBuilder())
+		}
+
+		return new RootObjectBuilder({ ...this.objects, [name]: builder }, this.fragmentDefinitions)
+	}
+}

package/src/graphQlBuilder/index.ts

@@ -0,0 +1,5 @@
+export * from './GraphQlLiteral'
+export * from './ObjectBuilder'
+export * from './QueryBuilder'
+export * from './QueryCompiler'
+export * from './RootObjectBuilder'

package/src/graphQlClient/GraphQlClient.ts

@@ -0,0 +1,52 @@
+export interface GraphQlClientRequestOptions {
+	variables?: GraphQlClientVariables
+	apiTokenOverride?: string
+	signal?: AbortSignal
+	headers?: Record<string, string>
+}
+
+export interface GraphQlClientVariables {
+	[name: string]: any
+}
+
+export type GraphQlClientFailedRequestMetadata = Pick<Response, 'status' | 'statusText'> & {
+	responseText: string
+}
+
+export class GraphQlClient {
+	constructor(public readonly apiUrl: string, private readonly apiToken?: string) { }
+
+	async sendRequest<T = unknown>(
+		query: string,
+		{ apiTokenOverride, signal, variables, headers }: GraphQlClientRequestOptions = {},
+	): Promise<T> {
+		const resolvedHeaders: Record<string, string> = { 'Content-Type': 'application/json', ...headers }
+		const resolvedToken = apiTokenOverride ?? this.apiToken
+
+		if (resolvedToken !== undefined) {
+			resolvedHeaders['Authorization'] = `Bearer ${resolvedToken}`
+		}
+
+		console.debug(query)
+
+		const response = await fetch(this.apiUrl, {
+			method: 'POST',
+			headers: resolvedHeaders,
+			signal,
+			body: JSON.stringify({ query, variables }),
+		})
+
+		if (response.ok) {
+			// It may still have errors (e.g. unfilled fields) but as far as the request goes, it is ok.
+			return await response.json()
+		}
+
+		const failedRequest: GraphQlClientFailedRequestMetadata = {
+			status: response.status,
+			statusText: response.statusText,
+			responseText: await response.text(),
+		}
+
+		return Promise.reject(failedRequest)
+	}
+}

package/src/graphQlClient/index.ts

@@ -0,0 +1 @@
+export * from './GraphQlClient'

package/src/index.ts

@@ -0,0 +1,49 @@
+import * as CrudQueryBuilderTmp from './crudQueryBuilder'
+
+import * as GraphQlBuilderTmp from './graphQlBuilder'
+export { GraphQlLiteral } from './graphQlBuilder'
+
+export namespace GraphQlBuilder {
+	export import GraphqlLiteral = GraphQlBuilderTmp.GraphQlLiteral
+	export import GraphQlLiteral = GraphQlBuilderTmp.GraphQlLiteral
+	export import ObjectBuilder = GraphQlBuilderTmp.ObjectBuilder
+	export import QueryCompiler = GraphQlBuilderTmp.QueryCompiler
+	export import QueryBuilder = GraphQlBuilderTmp.QueryBuilder
+	export import RootObjectBuilder = GraphQlBuilderTmp.RootObjectBuilder
+}
+
+export namespace CrudQueryBuilder {
+	export import CrudQueryBuilder = CrudQueryBuilderTmp.CrudQueryBuilder
+	export import ReadBuilder = CrudQueryBuilderTmp.ReadBuilder
+	export import WriteBuilder = CrudQueryBuilderTmp.WriteBuilder
+	export import WriteDataBuilder = CrudQueryBuilderTmp.WriteDataBuilder
+	export import WriteManyRelationBuilder = CrudQueryBuilderTmp.WriteManyRelationBuilder
+	export import WriteOneRelationBuilder = CrudQueryBuilderTmp.WriteOneRelationBuilder
+	export import WriteOperation = CrudQueryBuilderTmp.WriteOperation
+	export type CreateMutationArguments = CrudQueryBuilderTmp.CreateMutationArguments
+	export type CreateMutationFields = CrudQueryBuilderTmp.CreateMutationFields
+	export type DeleteMutationArguments = CrudQueryBuilderTmp.DeleteMutationArguments
+	export type DeleteMutationFields = CrudQueryBuilderTmp.DeleteMutationFields
+	export type GetQueryArguments = CrudQueryBuilderTmp.GetQueryArguments
+	export type HasManyArguments = CrudQueryBuilderTmp.HasManyArguments
+	export type HasOneArguments = CrudQueryBuilderTmp.HasOneArguments
+	export type ListQueryArguments = CrudQueryBuilderTmp.ListQueryArguments
+	export type Mutations = CrudQueryBuilderTmp.Mutations
+	export type OrderDirection = CrudQueryBuilderTmp.OrderDirection
+	export type PaginateQueryArguments = CrudQueryBuilderTmp.PaginateQueryArguments
+	export type Queries = CrudQueryBuilderTmp.Queries
+	export type ReadArguments = CrudQueryBuilderTmp.ReadArguments
+	export type ReductionArguments = CrudQueryBuilderTmp.ReductionArguments
+	export type UpdateMutationArguments = CrudQueryBuilderTmp.UpdateMutationArguments
+	export type UpdateMutationFields = CrudQueryBuilderTmp.UpdateMutationFields
+	export type WriteArguments = CrudQueryBuilderTmp.WriteArguments
+	export type WriteFields = CrudQueryBuilderTmp.WriteFields
+	export type WriteRelationOps = CrudQueryBuilderTmp.WriteRelationOps
+}
+
+export * from './content'
+export * from './graphQlClient'
+export * from './system'
+export * from './tenant'
+
+export type { Input, Value, Result, Writable } from '@contember/schema'

package/src/system/events/RelationFilter.ts

@@ -0,0 +1,4 @@
+export interface RelationFilter {
+	name: string
+	relations: RelationFilter[]
+}

package/src/system/events/SystemEvent.ts

@@ -0,0 +1,9 @@
+export interface SystemEvent {
+	id: string
+	createdAt: string
+	type: 'CREATE' | 'UPDATE' | 'DELETE'
+	dependencies: string[]
+	description: string
+	identityDescription: string
+	transactionId: string
+}

package/src/system/events/TreeFilter.ts

@@ -0,0 +1,7 @@
+import type { RelationFilter } from './RelationFilter'
+
+export interface TreeFilter {
+	entity: string
+	id: string | number
+	relations: RelationFilter[]
+}

package/src/system/events/index.ts

@@ -0,0 +1,3 @@
+export * from './RelationFilter'
+export * from './SystemEvent'
+export * from './TreeFilter'

package/src/system/formatSystemApiRelativeUrl.ts

@@ -0,0 +1 @@
+export const formatSystemApiRelativeUrl = (projectSlug: string) => `/system/${projectSlug}`

package/src/system/index.ts

@@ -0,0 +1,2 @@
+export * from './events'
+export * from './formatSystemApiRelativeUrl'

package/src/tenant/index.ts

@@ -0,0 +1,3 @@
+export * from './loginMutation'
+export * from './tenantApiRelativeUrl'
+export * from './tenantErrorMessages'

package/src/tenant/loginMutation.ts

@@ -0,0 +1,61 @@
+export interface LoginMutationResponse {
+	data: {
+		signIn: {
+			ok: boolean
+			errors: Array<{
+				endUserMessage: string | null
+				code: string
+			}>
+			result: {
+				token: string
+				person: {
+					id: string
+					email: string
+					identity: {
+						id: string
+						projects: Array<{
+							project: {
+								id: string
+								slug: string
+							}
+							memberships: Array<{
+								role: string
+							}>
+						}>
+					}
+				}
+			} | null
+		}
+	}
+}
+
+export const loginMutation = `
+	mutation($email: String!, $password: String!, $expiration: Int) {
+		signIn(email: $email, password: $password, expiration: $expiration) {
+			ok
+			errors {
+				endUserMessage
+				code
+			}
+			result {
+				token
+				person {
+					id
+					email
+					identity {
+						id
+						projects {
+							project {
+								id
+								slug
+							}
+							memberships {
+								role
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+`