@contember/cli 1.4.0-rc.7 → 2.0.0-alpha.10

package/src/utils/tenant.ts

@@ -1,434 +0,0 @@
-import prompts from 'prompts'
-import { GraphQLClient } from 'graphql-request'
-import { InstanceApiEnvironment } from './instance'
-import { Workspace } from '@contember/cli-common'
-
-const validatePassword = (password: string) =>
-	password.length < 6 ? 'Password must contain at least 6 characters' : true
-
-export const createTenantApiUrl = (url: string) => {
-	if (url.endsWith('/')) {
-		url = url.substring(0, url.length - 1)
-	}
-	if (url.endsWith('/tenant')) {
-		return url
-	}
-	return url + '/tenant'
-}
-
-export const interactiveResolveLoginToken = async (workspace: Workspace) => {
-	if (workspace.env.loginToken) {
-		return workspace.env.loginToken
-	}
-	const { loginToken } = await prompts({
-		type: 'text',
-		name: 'loginToken',
-		message: 'Login token',
-	})
-	return loginToken
-}
-
-export const interactiveSignIn = async ({
-	apiUrl,
-	loginToken,
-	expiration,
-}: {
-	apiUrl: string
-	loginToken: string
-	expiration?: number
-}): Promise<{ sessionToken: string }> => {
-	const { email, password } = await prompts([
-		{
-			type: 'text',
-			name: 'email',
-			message: 'E-mail',
-		},
-		{
-			type: 'password',
-			name: 'password',
-			message: 'Password',
-		},
-	])
-	if (!expiration) {
-		({ expiration } = await prompts({
-			type: 'number',
-			name: 'expiration',
-			message: 'Expiration in seconds',
-			float: false,
-			initial: 3600 * 365,
-		}))
-	}
-	const client = TenantClient.create(apiUrl, loginToken)
-	return await client.signIn(email, password, expiration || 3600)
-}
-
-export const interactiveResolveApiToken = async ({
-	workspace,
-	instance,
-	apiToken,
-}: {
-	workspace: Workspace
-	instance: InstanceApiEnvironment
-	apiToken?: string
-}): Promise<string> => {
-	if (apiToken) {
-		return apiToken
-	}
-	if (workspace.env.apiToken) {
-		return workspace.env.apiToken
-	}
-	const { strategy } = await prompts({
-		type: 'select',
-		name: 'strategy',
-		message: 'Authentication',
-		choices: [
-			{ value: 'signin', title: 'Sign in using email and password' },
-			{ value: 'token', title: 'Enter an API token' },
-		],
-	})
-	if (strategy === 'signin') {
-		const loginToken = await interactiveResolveLoginToken(workspace)
-		return (await interactiveSignIn({ apiUrl: createTenantApiUrl(instance.baseUrl), loginToken, expiration: 60 * 5 }))
-			.sessionToken
-	}
-	const { token } = await prompts({
-		type: 'text',
-		name: 'token',
-		message: 'API token',
-	})
-
-	return token
-}
-
-export const interactiveInvite = async ({ client }: { client: TenantClient }): Promise<void> => {
-	const { project, memberships } = await interactiveResolveMemberships({ client })
-
-	const { email } = await prompts({
-		name: 'email',
-		type: 'text',
-		validate: (value: string) => (value.includes('@') ? true : 'Not a valid e-mail'),
-		message: 'User e-mail',
-	})
-
-	console.log(`email: ${email}`)
-	console.log(`project: ${project.slug}`)
-	console.log('memberships:')
-	console.log(JSON.stringify(memberships, null, '  '))
-	const { ok } = await prompts({
-		name: 'ok',
-		message: 'Are you sure you want to invite this user?',
-		type: 'confirm',
-		inactive: 'no, start again',
-	})
-	if (!ok) {
-		return await interactiveInvite({ client })
-	}
-
-	await client.invite(email, project.slug, memberships)
-}
-
-export const interactiveCreateApiKey = async ({
-	client,
-}: {
-	client: TenantClient
-}): Promise<{ id: string; token: string }> => {
-	const { project, memberships } = await interactiveResolveMemberships({ client })
-
-	const { description } = await prompts({
-		name: 'description',
-		type: 'text',
-		message: 'API key description (e.g. "a key for mobile app")',
-	})
-
-	console.log(`project: ${project.slug}`)
-	console.log('memberships:')
-	console.log(JSON.stringify(memberships, null, '  '))
-	const { ok } = await prompts({
-		name: 'ok',
-		message: 'Are you sure you want to create this API key?',
-		type: 'confirm',
-		inactive: 'no, start again',
-	})
-	if (!ok) {
-		return await interactiveCreateApiKey({ client })
-	}
-
-	return await client.createApiKey(project.slug, memberships, description)
-}
-
-const interactiveResolveMemberships = async ({
-	client,
-}: {
-	client: TenantClient
-}): Promise<{ project: Project; memberships: Membership[] }> => {
-	const projects = await client.listProjects()
-	const { projectSlug } = await prompts({
-		type: 'select',
-		message: 'Project',
-		name: 'projectSlug',
-		choices: projects.map(it => ({ value: it.slug, title: it.slug })),
-	})
-	const project = projects.find(it => it.slug === projectSlug)
-	if (!project) {
-		throw new Error()
-	}
-	const memberships: Membership[] = []
-	let choices = project.roles.map(({ name }) => ({ value: name, title: name }))
-	let another = false
-	do {
-		const { roleName } = await prompts({
-			type: 'select',
-			message: 'Role',
-			name: 'roleName',
-			choices: choices,
-		})
-		choices = choices.filter(it => it.value !== roleName)
-		const role = project.roles.find(it => it.name === roleName)
-		if (!role) {
-			throw new Error()
-		}
-		const membership: Membership = { role: role.name, variables: [] }
-		memberships.push(membership)
-		for (const variable of role.variables) {
-			const { values } = await prompts({
-				type: 'list',
-				message: `Values for ${variable.name} (comma separated)`,
-				name: 'values',
-				// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-				// @ts-ignore
-				separator: ',',
-			})
-			membership.variables.push({ name: variable.name, values })
-		}
-		if (choices.length) {
-			({ another } = await prompts({
-				name: 'another',
-				message: 'Do you want to add another role?',
-				type: 'confirm',
-				initial: false,
-			}))
-		} else {
-			another = false
-		}
-	} while (another)
-	return { project, memberships }
-}
-
-export const interactiveResetPassword = async ({
-	apiUrl,
-	loginToken,
-}: {
-	apiUrl: string
-	loginToken: string
-}): Promise<void> => {
-	const { email } = await prompts([
-		{
-			type: 'text',
-			name: 'email',
-			message: 'E-mail',
-		},
-	])
-	if (!email) {
-		throw `Aborted`
-	}
-	const client = TenantClient.create(apiUrl, loginToken)
-	await client.createResetPasswordRequest(email)
-	console.log('A reset token has been sent to given email')
-
-	const { token, password } = await prompts([
-		{
-			type: 'text',
-			name: 'token',
-			message: 'Token',
-		},
-		{
-			type: 'password',
-			name: 'password',
-			message: 'Password',
-			validate: validatePassword,
-		},
-	])
-	if (!token || !password) {
-		throw 'Aborted'
-	}
-	await client.resetPassword(token, password)
-
-	console.log('Password reset successful. You can now login using a new password')
-}
-
-type MembershipVariable = {
-	name: string
-	values: string[]
-}
-type Membership = {
-	role: string
-	variables: MembershipVariable[]
-}
-
-interface Project {
-	slug: string
-	roles: {
-		name: string
-		variables: {
-			name: string
-		}[]
-	}[]
-}
-
-export class TenantClient {
-	constructor(private readonly apiClient: GraphQLClient) {}
-
-	public static create(url: string, apiToken: string): TenantClient {
-		const graphqlClient = new GraphQLClient(createTenantApiUrl(url), {
-			headers: {
-				Authorization: `Bearer ${apiToken}`,
-			},
-		})
-		return new TenantClient(graphqlClient)
-	}
-
-	public async createApiKey(
-		projectSlug: string,
-		memberships: Membership[],
-		description: string,
-	): Promise<{ id: string; token: string }> {
-		const query = `mutation($projectSlug: String!, $memberships: [MembershipInput!]!, $description: String!) {
-  createApiKey(projectSlug: $projectSlug, memberships: $memberships, description: $description) {
-    ok
-    errors {
-      code
-    }
-    result {
-      apiKey {
-        id
-        token
-      }
-    }
-  }
-}`
-		const response = await this.apiClient.request<{
-			createApiKey: { ok: boolean; errors: { code: string }[]; result: { apiKey: { id: string; token: string } } }
-		}>(query, { projectSlug, memberships, description })
-		if (!response.createApiKey.ok) {
-			throw response.createApiKey.errors.map((it: any) => it.code)
-		}
-		return response.createApiKey.result.apiKey
-	}
-
-	public async invite(email: string, projectSlug: string, memberships: Membership[]): Promise<void> {
-		const query = `mutation($projectSlug: String!, $memberships: [MembershipInput!]!, $email: String!) {
-  invite(projectSlug: $projectSlug, memberships: $memberships, email: $email) {
-    ok
-    errors {
-      code
-    }
-  }
-}`
-		const response = await this.apiClient.request<{ invite: { ok: boolean; errors: { code: string }[] } }>(query, {
-			projectSlug,
-			memberships,
-			email,
-		})
-		if (!response.invite.ok) {
-			throw response.invite.errors.map((it: any) => it.code)
-		}
-	}
-
-	public async listProjects(): Promise<Project[]> {
-		const response = await this.apiClient.request<{
-			me: { projects: { project: { slug: string; roles: { name: string; variables: { name: string }[] }[] } }[] }
-		}>(`query {
-  me {
-    projects {
-      project {
-        slug
-        roles {
-          name
-          variables {
-            name
-          }
-        }
-      }
-    }
-  }
-}`)
-
-		return response.me.projects.map((it: any) => it.project)
-	}
-
-	public async signIn(email: string, password: string, expiration: number): Promise<{ sessionToken: string }> {
-		const query = `mutation($email: String!, $password: String!, $expiration: Int!) {
-  signIn(email: $email, password: $password, expiration: $expiration) {
-    ok
-    errors {
-      code
-    }
-    result {
-      token
-    }
-  }
-}`
-
-		const result = await this.apiClient.request<{
-			signIn: { ok: boolean; errors: { code: string }[]; result: { token: string } }
-		}>(query, { email, password, expiration })
-		if (!result.signIn.ok) {
-			throw result.signIn.errors.map((it: any) => it.code)
-		}
-		return { sessionToken: result.signIn.result.token }
-	}
-
-	public async createResetPasswordRequest(email: string): Promise<void> {
-		const query = `mutation($email: String!) {
-  createResetPasswordRequest(email: $email) {
-    ok
-    errors {
-      code
-    }
-  }
-}`
-		const result = await this.apiClient.request<{
-			createResetPasswordRequest: { ok: boolean; errors: { code: string }[] }
-		}>(query, { email })
-		if (!result.createResetPasswordRequest.ok) {
-			throw result.createResetPasswordRequest.errors.map((it: any) => it.code)
-		}
-	}
-
-	public async resetPassword(token: string, password: string): Promise<void> {
-		const query = `mutation($token: String!, $password: String!) {
-  resetPassword(token: $token, password: $password) {
-    ok
-    errors {
-      code
-    }
-  }
-}`
-		const result = await this.apiClient.request<{
-			resetPassword: { ok: boolean; errors: { code: string }[] }
-		}>(query, { token, password })
-		if (!result.resetPassword.ok) {
-			throw result.resetPassword.errors.map((it: any) => it.code)
-		}
-	}
-
-	public async createProject(slug: string, ignoreExisting = false): Promise<void> {
-		const query = `mutation($slug: String!) {
-  createProject(projectSlug: $slug) {
-    ok
-    error {
-      code
-    }
-  }
-}`
-		const result = await this.apiClient.request<{
-			createProject: { ok: boolean; error: { code: string } }
-		}>(query, { slug })
-		if (!result.createProject.ok) {
-			if (ignoreExisting && result.createProject.error.code === 'ALREADY_EXISTS') {
-				return
-			}
-			throw result.createProject.error.code
-		}
-	}
-}

package/src/utils/tuple.ts

@@ -1 +0,0 @@
-export const tuple = <T extends any[]>(...values: T) => values

package/src/utils/workspace.ts

@@ -1,21 +0,0 @@
-import { formatWorkspaceConfigPath, pathExists, Workspace } from '@contember/cli-common'
-import { updateYaml } from './yaml'
-
-export const updateWorkspaceApiVersion = async (workspace: Workspace, newVersion: string): Promise<string | null> => {
-	const possiblePaths = formatWorkspaceConfigPath(workspace.directory)
-	for (const configPath of possiblePaths) {
-		if (await pathExists(configPath)) {
-			await updateYaml(configPath, data => {
-				return {
-					...data,
-					api: {
-						...(typeof data.api === 'object' ? data.api : {}),
-						version: newVersion,
-					},
-				}
-			})
-			return configPath.slice(workspace.directory.length)
-		}
-	}
-	return null
-}

package/src/utils/yaml.ts

@@ -1,36 +0,0 @@
-import { JSONObject, JSONPrimitive, pathExists } from '@contember/cli-common'
-import YAWN from 'yawn-yaml'
-import { Merger } from '@contember/config-loader'
-import jsyaml from 'js-yaml'
-import { readFile, writeFile } from 'node:fs/promises'
-
-export type JsonUpdateCallback<Value = JSONObject> = (
-	data: Partial<Value>,
-	utils: { merge: (a: JSONObject, b: JSONObject) => JSONObject },
-) => Value
-
-export const updateYaml = async <Value = JSONObject>(
-	path: string,
-	updater: JsonUpdateCallback<Value>,
-	options: { createMissing?: boolean } = {},
-) => {
-	let config = ''
-	if (await pathExists(path)) {
-		config = await readFile(path, { encoding: 'utf8' })
-	} else if (options.createMissing !== true) {
-		throw new Error(`File ${path} does not exist.`)
-	}
-
-	let newConfig = ''
-	const mergeUtils = { merge: (a: JSONObject, b: JSONObject) => Merger.merge<JSONPrimitive>(a, b) }
-	if (config) {
-		const yawn = new YAWN(config)
-		yawn.json = updater(yawn.json, mergeUtils)
-		newConfig = yawn.yaml
-	} else {
-		newConfig = jsyaml.dump(updater({}, mergeUtils))
-	}
-
-	await writeFile(path, newConfig, { encoding: 'utf8' })
-}
-