@contember/cli 2.1.0-alpha.8 → 2.1.0-beta.1

package/src/lib/migrations/MigrationsStatusFacade.ts

@@ -1,22 +1,22 @@
-import { MigrationsResolver, MigrationsStatusResolver, SystemClient } from '@contember/migrations-client'
-import { createMigrationStatusTable } from './migrations'
+import { MigrationsResolver, MigrationsStatusResolver } from '@contember/migrations-client'
 import { SystemClientProvider } from '../SystemClientProvider'
+import { MigrationPrinter } from './MigrationPrinter'
 
 export class MigrationsStatusFacade {
 	constructor(
 		private readonly systemClientProvider: SystemClientProvider,
 		private readonly migrationsResolver: MigrationsResolver,
 		private readonly migrationsStatusResolver: MigrationsStatusResolver,
+		private readonly migrationPrinter: MigrationPrinter,
 	) {
 	}
 
-
 	public resolveMigrationsStatus = async ({ force, allowError }: { force?: boolean; allowError?: boolean }) => {
 		const executedMigrations = await this.systemClientProvider.get().listExecutedMigrations()
 		const localMigrations = await this.migrationsResolver.getMigrationFiles()
 		const status = await this.migrationsStatusResolver.getMigrationsStatus(executedMigrations, localMigrations, force)
 		if (status.errorMigrations.length > 0 && !allowError) {
-			console.error(createMigrationStatusTable(status.errorMigrations))
+			console.error(this.migrationPrinter.printStatusTable(status.errorMigrations))
 			if (!force) {
 				throw `Cannot execute migrations`
 			}

package/src/lib/project/RemoteProjectResolver.ts

@@ -13,9 +13,9 @@ export class RemoteProjectResolver {
 		let token: string | undefined
 		let project: string | undefined
 		if (identifier?.includes('://')) {
-			({ endpoint, project, token } = parseDsn(identifier))
+			;({ endpoint, project, token } = parseDsn(identifier))
 		} else if (this.cliEnv.dsn) {
-			({ endpoint, project, token } = parseDsn(this.cliEnv.dsn))
+			;({ endpoint, project, token } = parseDsn(this.cliEnv.dsn))
 		} else {
 			endpoint = this.cliEnv.apiUrl
 			token = this.cliEnv.apiToken

package/src/lib/project/docs/components/EntityInfo.tsx

@@ -14,8 +14,7 @@ interface EntityInfoProps {
 }
 
 export const EntityInfo = ({ entity, schema, references }: EntityInfoProps) => (
-	<div class={'m-4 border border-gray-400 rounded-lg group'}
-		 id={formatEntityAnchor(entity.name)}>
+	<div class={'m-4 border border-gray-400 rounded-lg group'} id={formatEntityAnchor(entity.name)}>
 		<div class={'font-bold text-gray-900 py-2 px-4 border-b border-gray-400 group-target:bg-yellow-100 rounded-t-lg'}>
 			{entity.name}
 		</div>
@@ -26,60 +25,66 @@ export const EntityInfo = ({ entity, schema, references }: EntityInfoProps) => (
 						<tr>
 							<th class={'text-left px-2 text-gray-500 font-normal w-[180px] max-w-[180px]'}>Name</th>
 							<th class={'text-left px-2 text-gray-500 font-normal w-[340px] max-w-[340px]'}>Type</th>
-							{Object.keys(schema.acl.roles).map(role => <th
-								key={role}
-								class={'text-left px-2 text-gray-500 font-normal w-[120px] max-w-[120px] text-xs truncate text-sm'}>{role}</th>)}
+							{Object.keys(schema.acl.roles).map(role => (
+								<th
+									key={role}
+									class={'text-left px-2 text-gray-500 font-normal w-[120px] max-w-[120px] text-xs truncate text-sm'}
+								>
+									{role}
+								</th>
+							))}
 						</tr>
 					</thead>
 					<tr>
 						<td></td>
 						<td></td>
-						{Object.entries(schema.acl.roles).map(([name, role]) => <td class={'px-2'} key={name}>
-							<SinglePermission value={'D'}
-											  predicate={role.entities[entity.name]?.operations.delete} />
-						</td>)}
+						{Object.entries(schema.acl.roles).map(([name, role]) => (
+							<td class={'px-2'} key={name}>
+								<SinglePermission value={'D'} predicate={role.entities[entity.name]?.operations.delete} />
+							</td>
+						))}
 					</tr>
 					{Object.values(entity.fields).map(field => (
-						<tr class={'even:bg-gray-100 target:bg-yellow-100'}
-							id={formatFieldAnchor(entity.name, field.name)}
-							key={field.name}
-						>
+						<tr class={'even:bg-gray-100 target:bg-yellow-100'} id={formatFieldAnchor(entity.name, field.name)} key={field.name}>
 							<td class={'px-2 font-mono truncate  w-[180px] max-w-[180px]'} title={field.name}>
 								{field.name}
 							</td>
 							<td class={'text-gray-800 px-2 font-mono w-[420px] max-w-[420px]'}>
 								<FieldType field={field} />
 							</td>
-							{Object.entries(schema.acl.roles).map(([name, role]) => <td class={'px-2'} key={name}>
-								<FieldPermissions field={field.name}
-												  entityPermissions={role.entities[entity.name]} />
-							</td>)}
+							{Object.entries(schema.acl.roles).map(([name, role]) => (
+								<td class={'px-2'} key={name}>
+									<FieldPermissions field={field.name} entityPermissions={role.entities[entity.name]} />
+								</td>
+							))}
 						</tr>
 					))}
-
 				</table>
 			</div>
 			<div class={'px-2 py-2 w-1/2'}>
 				<h3 class={'text-lg text-gray-600'}>On delete behaviour:</h3>
 				<p class={'text-gray-500 text-sm'}>
-					(What happens when you attempt to delete entity {entity.name})</p>
+					(What happens when you attempt to delete entity {entity.name})
+				</p>
 				<div class={'mt-2 text-sm '}>
 					<OnDelete references={references} entity={entity} />
 				</div>
 			</div>
-			{false && <div class={'px-2 py-2 w-1/2'}>
-				<h3 class={'text-lg text-gray-600'}>ACL predicates:</h3>
-				<div class={'mt-2 text-sm '}>
-					{Object.entries(schema.acl.roles).map(([roleName, role]) =>
-						Object.entries(role.entities[entity.name]?.predicates ?? {}).map(([predicateName, predicate]) => (
-							<Fragment key={roleName + '__' + predicateName}>
-								<h4>{roleName}: {predicateName}</h4>
-								<code>{JSON.stringify(predicate)}</code>
-							</Fragment>
-						)),
-					)}
+			{false && (
+				<div class={'px-2 py-2 w-1/2'}>
+					<h3 class={'text-lg text-gray-600'}>ACL predicates:</h3>
+					<div class={'mt-2 text-sm '}>
+						{Object.entries(schema.acl.roles).map(([roleName, role]) =>
+							Object.entries(role.entities[entity.name]?.predicates ?? {}).map(([predicateName, predicate]) => (
+								<Fragment key={roleName + '__' + predicateName}>
+									<h4>{roleName}: {predicateName}</h4>
+									<code>{JSON.stringify(predicate)}</code>
+								</Fragment>
+							))
+						)}
+					</div>
 				</div>
-			</div>}
+			)}
 		</div>
 	</div>
 )

package/src/lib/project/docs/components/FieldLink.tsx

@@ -4,7 +4,11 @@ import { formatFieldAnchor } from './utils'
 
 export const FieldLink = ({ entity, field, noEntityLabel }: { entity: string; field: string; noEntityLabel?: boolean }) => (
 	<Fragment>
-		{noEntityLabel ? '' : <Fragment><EntityLink entity={entity} />.</Fragment>}
+		{noEntityLabel ? '' : (
+			<Fragment>
+				<EntityLink entity={entity} />.
+			</Fragment>
+		)}
 		<a href={`#${formatFieldAnchor(entity, field)}`} class={'text-blue-500 hover:underline'}>{field}</a>
 	</Fragment>
 )

package/src/lib/project/docs/components/FieldPermissions.tsx

@@ -2,13 +2,15 @@ import { Fragment, h } from 'preact'
 import { Acl } from '@contember/schema'
 import { SinglePermission } from './SinglePermission'
 
-export const FieldPermissions  = ({ entityPermissions, field }: { entityPermissions?: Acl.EntityPermissions; field: string }) => {
+export const FieldPermissions = ({ entityPermissions, field }: { entityPermissions?: Acl.EntityPermissions; field: string }) => {
 	const readPermissions = entityPermissions?.operations.read?.[field]
 	const updatePermissions = entityPermissions?.operations.update?.[field]
 	const createPermissions = entityPermissions?.operations.create?.[field]
-	return <Fragment>
-		<SinglePermission value={'C'} predicate={createPermissions} />
-		<SinglePermission value={'R'} predicate={readPermissions} />
-		<SinglePermission value={'U'} predicate={updatePermissions} />
-	</Fragment>
+	return (
+		<Fragment>
+			<SinglePermission value={'C'} predicate={createPermissions} />
+			<SinglePermission value={'R'} predicate={readPermissions} />
+			<SinglePermission value={'U'} predicate={updatePermissions} />
+		</Fragment>
+	)
 }

package/src/lib/project/docs/components/FieldType.tsx

@@ -1,45 +1,46 @@
 import { Model } from '@contember/schema'
-import { h, Fragment } from 'preact'
+import { Fragment, h } from 'preact'
 import { EntityLink } from './EntityLink'
 import { FieldLink } from './FieldLink'
 
 export const FieldType = ({ field }: { field: Model.AnyField }) => {
 	if (field.type === 'ManyHasMany') {
-		return <>
-			<EntityLink entity={field.target}/>[]{' '}
-			<TargetField field={field}/> (m:n)
-		</>
-
+		return (
+			<>
+				<EntityLink entity={field.target} />[] <TargetField field={field} /> (m:n)
+			</>
+		)
 	} else if (field.type === 'OneHasMany') {
-		return <>
-			<EntityLink entity={field.target}/>[]{' '}
-			<TargetField field={field}/> (1:n)
-		</>
-
+		return (
+			<>
+				<EntityLink entity={field.target} />[] <TargetField field={field} /> (1:n)
+			</>
+		)
 	} else if (field.type === 'OneHasOne') {
-		return <>
-			<NullableMark field={field} />
-			<EntityLink entity={field.target}/>{' '}
-			<TargetField field={field}/> (1:1)
-		</>
-
+		return (
+			<>
+				<NullableMark field={field} />
+				<EntityLink entity={field.target} /> <TargetField field={field} /> (1:1)
+			</>
+		)
 	} else if (field.type === 'ManyHasOne') {
-		return <>
-			<NullableMark field={field} />
-			<EntityLink entity={field.target}/>{' '}
-			<TargetField field={field}/> (m:1)
-		</>
-
+		return (
+			<>
+				<NullableMark field={field} />
+				<EntityLink entity={field.target} /> <TargetField field={field} /> (m:1)
+			</>
+		)
 	} else {
-		return <>
-			<NullableMark field={field} />
-			{field.type}
-		</>
-
+		return (
+			<>
+				<NullableMark field={field} />
+				{field.type}
+			</>
+		)
 	}
 }
 
-const TargetField = ({ field }: {field: Model.AnyRelation}) => {
+const TargetField = ({ field }: { field: Model.AnyRelation }) => {
 	if ('ownedBy' in field) {
 		return <FieldLink entity={field.target} field={field.ownedBy} noEntityLabel />
 	}
@@ -50,5 +51,5 @@ const TargetField = ({ field }: {field: Model.AnyRelation}) => {
 }
 
 const NullableMark = (props: { field: Model.NullableRelation | Model.AnyColumn }) => {
-	return props.field.nullable ? <span class={'font-bold color-black'}>? </span> : null
+	return props.field.nullable ? <span class={'font-bold color-black'}>?</span> : null
 }

package/src/lib/project/docs/components/OnDelete.tsx

@@ -1,4 +1,4 @@
-import { h, Fragment } from 'preact'
+import { Fragment, h } from 'preact'
 import { Model } from '@contember/schema'
 import { ReferenceMapEntry, ReferencesMap } from '../../../schema/collectReferences'
 import { FieldLink } from './FieldLink'
@@ -36,37 +36,39 @@ export const OnDelete = ({ references, entity, visited = [] }: { references: Ref
 				.sort(sortReferences)
 				.map(it => {
 					const inverseDescr = it.targetRelation
-						? <>see <FieldLink entity={entity.name} field={it.targetRelation.name} /></>
+						? (
+							<>
+								see <FieldLink entity={entity.name} field={it.targetRelation.name} />
+							</>
+						)
 						: 'no inverse side'
 					if (it.owningRelation.joiningColumn.onDelete === 'restrict') {
 						return (
 							<li key={it.owningEntity.name + '_' + it.owningRelation.name}>
-								<span class={'bg-black text-white px-1'}>Fails</span> when referenced from
-								{' '}<FieldLink entity={it.owningEntity.name} field={it.owningRelation.name} />
-								{' '}({inverseDescr})
+								<span class={'bg-black text-white px-1'}>Fails</span> when referenced from{' '}
+								<FieldLink entity={it.owningEntity.name} field={it.owningRelation.name} /> ({inverseDescr})
 							</li>
 						)
 					}
 					if (it.owningRelation.joiningColumn.onDelete === 'set null') {
 						return (
 							<li key={it.owningEntity.name + '_' + it.owningRelation.name}>
-								<span class={'bg-blue-400 text-white px-1'}>Sets null</span> at
-								{' '}<FieldLink entity={it.owningEntity.name} field={it.owningRelation.name} />
-								{' '}({inverseDescr})
+								<span class={'bg-blue-400 text-white px-1'}>Sets null</span> at <FieldLink entity={it.owningEntity.name} field={it.owningRelation.name} />
+								{' '}
+								({inverseDescr})
 							</li>
 						)
 					}
 					if (it.owningRelation.joiningColumn.onDelete === 'cascade') {
 						return (
 							<li key={it.owningEntity.name + '_' + it.owningRelation.name}>
-								<span class={'bg-red-400 text-white px-1'}>Deletes</span> <EntityLink entity={it.owningEntity.name} />
-								{' '}connected using
-								{' '}<FieldLink entity={it.owningEntity.name} field={it.owningRelation.name} noEntityLabel />
-								{' '}({inverseDescr})
+								<span class={'bg-red-400 text-white px-1'}>Deletes</span> <EntityLink entity={it.owningEntity.name} /> connected using{' '}
+								<FieldLink entity={it.owningEntity.name} field={it.owningRelation.name} noEntityLabel /> ({inverseDescr})
 								<OnDelete entity={it.owningEntity} visited={[...visited, entity]} references={references} />
 							</li>
 						)
 					}
 				})}
-		</ul>)
+		</ul>
+	)
 }

package/src/lib/project/docs/components/ProjectInfo.tsx

@@ -4,7 +4,6 @@ import { collectReferences } from '../../../schema/collectReferences'
 import { EntityLink } from './EntityLink'
 import { EntityInfo } from './EntityInfo'
 
-
 export const ProjectInfo = (props: { schema: Schema; projectName: string }) => {
 	const references = collectReferences(props.schema.model)
 
@@ -37,11 +36,9 @@ export const ProjectInfo = (props: { schema: Schema; projectName: string }) => {
 						</ul>
 					</div>
 				</div>
-
-
 			</div>
 			{Object.values(props.schema.model.entities).map(entity => (
-				<EntityInfo key={entity.name} entity={entity} schema={props.schema} references={references}/>
+				<EntityInfo key={entity.name} entity={entity} schema={props.schema} references={references} />
 			))}
 		</div>
 	)

package/src/lib/project/docs/components/SinglePermission.tsx

@@ -10,4 +10,3 @@ export const SinglePermission = ({ predicate, value }: { predicate?: Acl.Predica
 	}
 	return <span class={'bg-yellow-400 text-black font-semibold px-0.5'} title={predicate}>{value}</span>
 }
-

package/src/lib/project/docs/components/utils.ts

@@ -1,3 +1,2 @@
 export const formatEntityAnchor = (name: string) => `entity-${name}`
 export const formatFieldAnchor = (entity: string, field: string) => `field-${entity}--${field}`
-

package/src/lib/project/docs/projectDescribe.tsx

@@ -22,6 +22,4 @@ ${html}
 </body>
 </html>
 `
-
 }
-

package/src/lib/project/docs/resources/style.css

@@ -1,3 +1,2 @@
-@tailwind base;
-@tailwind components;
-@tailwind utilities;
+@import 'tailwindcss';
+@source "../../components/**/*.tsx";

package/src/lib/schema/SchemaLoader.ts

@@ -28,7 +28,7 @@ export class TranspilingSchemaLoader {
 	loadSchema = async (): Promise<Schema> => {
 		const path = join(this.workspace.apiDir, 'index.ts')
 
-		const result = (await this.jsCodeRunner.run(path))
+		const result = await this.jsCodeRunner.run(path)
 		return Typesafe.object({ default: schemaType })(result).default
 	}
 }

package/src/lib/schema/SchemaValidationPrinter.ts

@@ -1,6 +1,5 @@
 import { ValidationError } from '@contember/schema-utils'
 
-
 export const printValidationErrors = (errors: ValidationError[], message?: string) => {
 	if (errors.length === 0) {
 		return

package/src/lib/stream.ts

@@ -1,7 +1,6 @@
 import { Stream, Transform } from 'node:stream'
 import { Buffer } from 'node:buffer'
 
-
 export class LineTransform extends Transform {
 	private chunks: Buffer[] = []
 
@@ -35,10 +34,10 @@ export class LineTransform extends Transform {
 	}
 }
 
-
-export const readStream = async (stream: Stream) => new Promise<Buffer>((resolve, reject) => {
-	const chunks: Buffer[] = []
-	stream.on('error', err => reject(err))
-	stream.on('data', chunk => chunks.push(chunk))
-	stream.on('end', () => resolve(Buffer.concat(chunks)))
-})
+export const readStream = async (stream: Stream) =>
+	new Promise<Buffer>((resolve, reject) => {
+		const chunks: Buffer[] = []
+		stream.on('error', err => reject(err))
+		stream.on('data', chunk => chunks.push(chunk))
+		stream.on('end', () => resolve(Buffer.concat(chunks)))
+	})

package/src/lib/tenant/TenantClient.ts

@@ -10,7 +10,6 @@ export const createTenantApiUrl = (url: string) => {
 	return url + '/tenant'
 }
 
-
 export class TenantClient {
 	constructor(private readonly apiClient: GraphQlClient) {}
 

package/src/lib/transfer/DataTransferClient.ts

@@ -1,12 +1,9 @@
-import http from 'node:http'
-import https from 'node:https'
-import { LineTransform, readStream } from '../stream'
-import { Readable, Stream } from 'node:stream'
+import { LineTransform } from '../stream'
+import { Readable } from 'node:stream'
 import { createGzip } from 'node:zlib'
 import { RemoteProject } from '../project/RemoteProject'
 
 export class DataTransferClient {
-
 	dataImport = async ({ printProgress, stream, project, gzip }: {
 		stream: Readable
 		project: RemoteProject
@@ -18,96 +15,81 @@ export class DataTransferClient {
 		let rowTotal = 0
 		let transferred = 0
 		let start = Date.now()
-		const inputStream = stream.pipe(new LineTransform(line => {
-			transferred += line.length + 1
-			if (line === '') {
-				return ''
-			}
-			const data = JSON.parse(line)
-			switch (data[0]) {
-				case 'importSystemSchemaBegin':
-					return JSON.stringify([data[0], { ...data[1], project: project.name }])
-				case 'importContentSchemaBegin':
-					return JSON.stringify([data[0], { ...data[1], project: project.name }])
-				case 'insertBegin':
-					table = data[1].table
-					rowCount = 0
-					break
-				case 'insertRow':
-					rowCount++
-					rowTotal++
-					break
-				case 'insertEnd':
-					break
-			}
-			if ((rowCount % 1000) === 0 || data[0] !== 'insertRow') {
-				const mbs = Math.floor(transferred / 1024 / 1024).toString()
-				const durationS = Math.floor((Date.now() - start) / 1000)
-				printProgress(`transferred ${mbs} MiB; inserted ${rowCount} ${table} rows, ${rowTotal} total; ${durationS} seconds`)
-			}
-			return line
-		}))
+		const inputStream = stream.pipe(
+			new LineTransform(line => {
+				transferred += line.length + 1
+				if (line === '') {
+					return ''
+				}
+				const data = JSON.parse(line)
+				switch (data[0]) {
+					case 'importSystemSchemaBegin':
+						return JSON.stringify([data[0], { ...data[1], project: project.name }])
+					case 'importContentSchemaBegin':
+						return JSON.stringify([data[0], { ...data[1], project: project.name }])
+					case 'insertBegin':
+						table = data[1].table
+						rowCount = 0
+						break
+					case 'insertRow':
+						rowCount++
+						rowTotal++
+						break
+					case 'insertEnd':
+						break
+				}
+				if ((rowCount % 1000) === 0 || data[0] !== 'insertRow') {
+					const mbs = Math.floor(transferred / 1024 / 1024).toString()
+					const durationS = Math.floor((Date.now() - start) / 1000)
+					printProgress(`transferred ${mbs} MiB; inserted ${rowCount} ${table} rows, ${rowTotal} total; ${durationS} seconds`)
+				}
+				return line
+			}),
+		)
+		inputStream.on('error', err => {
+			throw new Error(`Input stream error: ${err}`)
+		})
 
-		return await this.executeRequest({
-			url: `${project.endpoint}/import`,
-			token: project.token,
+		const bodyStream = Readable.toWeb(gzip ? inputStream.pipe(createGzip()) : inputStream) as unknown as BodyInit
+
+		const response = await fetch(`${project.endpoint}/import`, {
 			headers: {
+				'Authorization': `Bearer ${project.token}`,
 				'Content-type': 'application/x-ndjson',
 				...(gzip ? { 'Content-Encoding': 'gzip' } : {}),
 			},
-			body: gzip ? inputStream.pipe(createGzip()) : inputStream,
+			method: 'POST',
+			body: bodyStream,
+			...{ duplex: 'half' },
 		})
+		if (!response.ok) {
+			const responseBody = await response.text()
+			throw new Error(`Invalid response: ${response.statusText}\n${responseBody}`)
+		}
+		return response
 	}
 
-
 	dataExport = async ({ project: { name: project, token, endpoint: baseUrl }, gzip, includeSystem, excludeTables }: {
 		project: RemoteProject
 		excludeTables?: string[]
 		includeSystem: boolean
 		gzip: boolean
 	}) => {
-		return await this.executeRequest({
-			url: `${baseUrl}/export`,
-			token,
+		const response = await fetch(`${baseUrl}/export`, {
 			headers: {
+				'Authorization': `Bearer ${token}`,
 				'Accept-Encoding': gzip ? 'gzip' : 'identity',
 				'Content-type': 'application/json',
 			},
+			method: 'POST',
 			body: JSON.stringify({
 				projects: [{ slug: project, system: includeSystem, excludeTables }],
 			}),
 		})
-	}
-
-
-	private executeRequest = async ({ url, token, headers, body }: {
-		url: string
-		token: string
-		headers: Record<string, string>
-		body: any
-	}) => {
-		return await new Promise<http.IncomingMessage>((resolve, reject) => {
-			const req = (url.startsWith('https://') ? https : http).request(url, {
-				method: 'POST',
-				headers: {
-					Authorization: `Bearer ${token}`,
-					...headers,
-				},
-			}, async res => {
-				if (res.statusCode !== 200) {
-					const responseBody = (await readStream(res)).toString()
-					reject(new Error(`Invalid response: ${res.statusMessage}\n${responseBody}`))
-				} else {
-					resolve(res)
-				}
-			})
-
-			if (body instanceof Stream) {
-				body.pipe(req)
-			} else {
-				req.write(body)
-				req.end()
-			}
-		})
+		if (!response.ok) {
+			const responseBody = await response.text()
+			throw new Error(`Invalid response: ${response.statusText}\n${responseBody}`)
+		}
+		return response
 	}
 }

package/src/lib/transfer/stdio.ts

@@ -6,4 +6,3 @@ export const printProgressLine = (message: string) => {
 	process.stdout.cursorTo(0)
 	process.stdout.write(message)
 }
-

package/src/lib/workspace/WorkspaceResolver.ts

@@ -1,5 +1,5 @@
 import { Workspace } from './Workspace'
-import { join } from 'node:path'
+import { join, resolve } from 'node:path'
 import { YamlHandler } from '../fs/YamlHandler'
 
 export interface LocalProjectConfig {
@@ -17,10 +17,10 @@ export class WorkspaceResolver {
 
 	resolve = async (baseDir: string): Promise<Workspace> => {
 		const config = await this.readConfig(baseDir)
-		const apiDir = config.apiDir ?? join(baseDir, 'api')
-		const migrationsDir = config.migrationsDir ?? join(apiDir, 'migrations')
-		const adminDir = config.adminDir === false ? undefined : (config.adminDir ?? join(baseDir, 'admin'))
-		const adminDistDir = adminDir === undefined ? undefined : (config.adminDistDir ?? join(adminDir, 'dist'))
+		const apiDir = config.apiDir ? resolve(baseDir, config.apiDir) : join(baseDir, 'api')
+		const migrationsDir = config.migrationsDir ? resolve(baseDir, config.migrationsDir) : join(apiDir, 'migrations')
+		const adminDir = config.adminDir === false ? undefined : (config.adminDir ? resolve(baseDir, config.adminDir) : join(baseDir, 'admin'))
+		const adminDistDir = adminDir === undefined ? undefined : (config.adminDistDir ? resolve(baseDir, config.adminDistDir) : join(adminDir, 'dist'))
 
 		return {
 			baseDir,

package/src/run.ts

@@ -5,10 +5,8 @@ import { createContainer } from './dic'
 import { readCliEnv } from './lib/env'
 import { WorkspaceResolver } from './lib/workspace/WorkspaceResolver'
 import { YamlHandler } from './lib/fs/YamlHandler'
-import { FileSystem } from './lib/fs/FileSystem';
-
-(async () => {
-	// eslint-disable-next-line @typescript-eslint/no-var-requires
+import { FileSystem } from './lib/fs/FileSystem'
+;(async () => {
 	const version = require(join(packageRoot, 'package.json')).version
 	const nodeVersion = process.version.match(/^v?(\d+)\..+$/)
 	if (nodeVersion && Number(nodeVersion[1]) < 18) {
@@ -25,7 +23,6 @@ import { FileSystem } from './lib/fs/FileSystem';
 		runtime: process.title === 'bun' ? 'bun' : 'node',
 	})
 
-
 	await dic.application.run(process.argv.slice(2))
 })().catch(e => {
 	console.log(e)