@contember/client 1.0.0-rc.2 → 1.0.0-rc.4

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 = []
+		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 = any>(
+		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,11 @@
+import * as CrudQueryBuilder from './crudQueryBuilder'
+import * as GraphQlBuilder from './graphQlBuilder'
+
+export { GraphQlLiteral } from './graphQlBuilder'
+export { GraphQlBuilder, CrudQueryBuilder }
+export * from './content'
+export * from './graphQlClient'
+export * from './system'
+export * from './tenant'
+
+export type { Input, Value, Result } 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
+	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
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+`

package/src/tenant/tenantApiRelativeUrl.ts

@@ -0,0 +1 @@
+export const tenantApiRelativeUrl = '/tenant'

package/src/tenant/tenantErrorMessages.ts

@@ -0,0 +1,14 @@
+export const tenantErrorMessages: { [key: string]: string } = {
+	TOO_WEAK: 'Password is too weak.',
+	EMAIL_ALREADY_EXISTS: 'Email already exists.',
+	UNKNOWN_EMAIL: 'Unknown email.',
+	INVALID_PASSWORD: 'Password is invalid.',
+	ALREADY_MEMBER: 'User is already a member of this project.',
+}
+
+export const getTenantErrorMessage = (errorCode: string): string => {
+	if (errorCode in tenantErrorMessages) {
+		return tenantErrorMessages[errorCode]
+	}
+	return `Unknown error occurred. [${errorCode}]`
+}

package/src/tsconfig.json

@@ -0,0 +1,6 @@
+{
+	"extends": "../tsconfig.settings.json",
+	"compilerOptions": {
+		"outDir": "../dist/types"
+	}
+}

package/src/utils/index.ts

@@ -0,0 +1,2 @@
+export * from './isEmptyObject'
+export * from './readFileAsArrayBuffer'

package/src/utils/isEmptyObject.ts

@@ -0,0 +1,9 @@
+export const isEmptyObject = (arg: object): boolean => {
+	// This is faster than Object.keys(arg).length === 0 && arg.constructor === Object
+	for (const key in arg) {
+		if (arg.hasOwnProperty(key)) {
+			return false
+		}
+	}
+	return true
+}

package/src/utils/readFileAsArrayBuffer.ts

@@ -0,0 +1,12 @@
+export const readFileAsArrayBuffer = (file: File): Promise<string | ArrayBuffer> =>
+	new Promise((resolve, reject) => {
+		const reader = new FileReader()
+		reader.onload = () => {
+			if (reader.result === null) {
+				reject()
+				return
+			}
+			resolve(reader.result)
+		}
+		reader.readAsArrayBuffer(file)
+	})