@fabrika/provider-zerops 0.0.1

package/src/authoring.ts

@@ -0,0 +1,33 @@
+import { ZEROPS_SHARED_POSTGRES_CONNECTION_STRING } from './namespace'
+export { zeropsSharedServiceHostname, zeropsSharedServicePrefix } from './service-names'
+import { APP_PROVIDER, isProviderAuthoredApp, type ProviderAuthoredApp } from '@fabrika/provider-contract'
+import type { ZeropsAppConfig, ZeropsSharedPostgresBinding } from './types'
+
+/** Declare consumption of the namespace-owned `postgres` service without resolving its credential. */
+export const useSharedPostgres = (): ZeropsSharedPostgresBinding => ({
+	resourceKey: 'service:postgres',
+	hostname: 'postgres',
+	connectionString: ZEROPS_SHARED_POSTGRES_CONNECTION_STRING,
+})
+
+/** Provider-specific authoring identity with complete Zerops contextual typing. */
+export type ZeropsAuthoredAppConfig = ZeropsAppConfig & ProviderAuthoredApp<'zerops'>
+
+export const defineApp = (config: ZeropsAppConfig): ZeropsAuthoredAppConfig => {
+	if (config.id.trim() === '') {
+		throw new Error('defineApp: `id` is required and must be a non-empty string')
+	}
+	return { ...config, [APP_PROVIDER]: 'zerops' }
+}
+
+const property = (value: unknown, key: string): unknown => typeof value === 'object' && value !== null ? Reflect.get(value, key) : undefined
+
+export const isZeropsAppConfig = (value: unknown): value is ZeropsAuthoredAppConfig => {
+	const id = property(value, 'id')
+	const target = property(value, 'target')
+	return isProviderAuthoredApp(value, 'zerops')
+		&& typeof id === 'string'
+		&& id.trim() !== ''
+		&& property(target, 'platform') === 'zerops'
+		&& typeof property(target, 'services') === 'function'
+}

package/src/cli-args.ts

@@ -0,0 +1,101 @@
+export interface ZeropsCliArgs {
+	command: string | undefined
+	subcommand: string | undefined
+	env: string | undefined
+	config: string
+	output: string
+	namespaceId: string | undefined
+	preset: string | undefined
+	exclusiveAppId: string | undefined
+	projectId: string | undefined
+	projectName: string | undefined
+	corePackage: string | undefined
+	publicAccess: string | undefined
+	postgresType: string | undefined
+	postgresProfile: string | undefined
+	proxyBuildFromGit: string | undefined
+	controlUrl: string | undefined
+	help: boolean
+}
+
+export const parseZeropsCliArgs = (argv: readonly string[]): ZeropsCliArgs => {
+	let command: string | undefined
+	let subcommand: string | undefined
+	let env: string | undefined
+	let config = './fabrika.config.ts'
+	let output = './fabrika.manifest.json'
+	let namespaceId: string | undefined
+	let preset: string | undefined
+	let exclusiveAppId: string | undefined
+	let projectId: string | undefined
+	let projectName: string | undefined
+	let corePackage: string | undefined
+	let publicAccess: string | undefined
+	let postgresType: string | undefined
+	let postgresProfile: string | undefined
+	let proxyBuildFromGit: string | undefined
+	let controlUrl: string | undefined
+	let help = false
+
+	for (const arg of argv) {
+		if (arg === '-h' || arg === '--help') {
+			help = true
+		} else if (arg.startsWith('--env=')) {
+			env = arg.slice('--env='.length)
+		} else if (arg.startsWith('--config=')) {
+			config = arg.slice('--config='.length)
+		} else if (arg.startsWith('--output=')) {
+			output = arg.slice('--output='.length)
+		} else if (arg.startsWith('--id=')) {
+			namespaceId = arg.slice('--id='.length)
+		} else if (arg.startsWith('--preset=')) {
+			preset = arg.slice('--preset='.length)
+		} else if (arg.startsWith('--exclusive-app=')) {
+			exclusiveAppId = arg.slice('--exclusive-app='.length)
+		} else if (arg.startsWith('--project-id=')) {
+			projectId = arg.slice('--project-id='.length)
+		} else if (arg.startsWith('--project-name=')) {
+			projectName = arg.slice('--project-name='.length)
+		} else if (arg.startsWith('--core-package=')) {
+			corePackage = arg.slice('--core-package='.length)
+		} else if (arg.startsWith('--public-access=')) {
+			publicAccess = arg.slice('--public-access='.length)
+		} else if (arg.startsWith('--postgres-type=')) {
+			postgresType = arg.slice('--postgres-type='.length)
+		} else if (arg.startsWith('--postgres-profile=')) {
+			postgresProfile = arg.slice('--postgres-profile='.length)
+		} else if (arg.startsWith('--proxy-build-from-git=')) {
+			proxyBuildFromGit = arg.slice('--proxy-build-from-git='.length)
+		} else if (arg.startsWith('--control-url=')) {
+			controlUrl = arg.slice('--control-url='.length)
+		} else if (arg.startsWith('-')) {
+			throw new Error(`Unknown option: ${arg}`)
+		} else if (command === undefined) {
+			command = arg
+		} else if (subcommand === undefined && command === 'namespace') {
+			subcommand = arg
+		} else {
+			throw new Error(`Unexpected argument: ${arg}`)
+		}
+	}
+
+	return {
+		command,
+		subcommand,
+		env,
+		config,
+		output,
+		namespaceId,
+		preset,
+		exclusiveAppId,
+		projectId,
+		projectName,
+		corePackage,
+		publicAccess,
+		postgresType,
+		postgresProfile,
+		proxyBuildFromGit,
+		controlUrl,
+		help,
+	}
+}

package/src/cli.ts

@@ -0,0 +1,82 @@
+#!/usr/bin/env bun
+import { resolve } from 'node:path'
+import { isZeropsAppConfig } from './authoring'
+import { parseZeropsCliArgs } from './cli-args'
+import { compileFabrikaManifest, manifestServiceHostnames } from './manifest'
+import { runZeropsNamespaceCommand } from './namespace-command'
+import type { ZeropsAppConfig } from './types'
+
+const USAGE = `Zerops app tools
+
+Usage:
+  fabrika app build --provider=zerops --env=<env> [--config=<path>] [--output=<path>]
+  fabrika namespace plan --provider=zerops --id=<id> --env=<env> --preset=<cheap|mid|full> [namespace options]
+  fabrika namespace create --provider=zerops --id=<id> --env=<env> --preset=<cheap|mid|full> [namespace options] [--control-url=<url>]
+  fabrika namespace adopt --provider=zerops --id=<id> --env=<env> --preset=<cheap|mid|full> --project-id=<id> [namespace options] [--control-url=<url>]
+  fabrika namespace reconcile --provider=zerops --id=<id> [--control-url=<url>]
+
+Options:
+  --env=<env>                    Environment.
+  --config=<path>                App config (default: ./fabrika.config.ts).
+  --output=<path>                Artifact path (default: ./fabrika.manifest.json).
+  --id=<id>                      Namespace id.
+  --preset=<cheap|mid|full>      Provider-owned namespace preset.
+  --exclusive-app=<id>           App reserved by a full namespace.
+  --project-id=<id>              Existing Zerops project id for adoption.
+  --project-name=<name>          Zerops project name (default: namespace id).
+  --core-package=<tier>          LIGHT or SERIOUS.
+  --public-access=<mode>         custom-domain or zerops-subdomain.
+  --postgres-type=<type>         Cheap-tier PostgreSQL type.
+  --postgres-profile=<profile>   Cheap-tier PostgreSQL profile.
+  --proxy-build-from-git=<url>   Public proxy source; or FABRIKA_ZEROPS_PROXY_BUILD_FROM_GIT.
+  --control-url=<url>            Control origin; or FABRIKA_CONTROL_URL.
+  -h, --help                     Show this help.
+
+Mutating namespace commands read the Bearer credential from FABRIKA_CONTROL_TOKEN.
+`
+
+const property = (value: unknown, key: string): unknown => typeof value === 'object' && value !== null ? Reflect.get(value, key) : undefined
+
+const loadConfig = async (path: string): Promise<ZeropsAppConfig> => {
+	const absolute = resolve(process.cwd(), path)
+	const loaded: unknown = await import(absolute)
+	const config = property(loaded, 'default')
+	if (!isZeropsAppConfig(config)) {
+		throw new Error(`Config at ${absolute} must default-export defineApp({ target: { platform: 'zerops', ... } })`)
+	}
+	return config
+}
+
+export const runZeropsCli = async (argv: readonly string[]): Promise<void> => {
+	const args = parseZeropsCliArgs(argv)
+	if (args.help || args.command === undefined) {
+		console.info(USAGE)
+		return
+	}
+	if (args.command === 'namespace') {
+		await runZeropsNamespaceCommand(args, {
+			source: process.env,
+			fetch: globalThis.fetch,
+			write: (value) => console.info(value.trimEnd()),
+		})
+		return
+	}
+	if (args.command !== 'build') {
+		throw new Error(`Unknown command: ${args.command}\n${USAGE}`)
+	}
+	if (args.env === undefined || args.env === '') {
+		throw new Error('`build` requires --env=<env>')
+	}
+	const config = await loadConfig(args.config)
+	const manifest = compileFabrikaManifest(config, args.env)
+	const output = resolve(process.cwd(), args.output)
+	await Bun.write(output, `${JSON.stringify(manifest, null, '\t')}\n`)
+	console.info(`wrote ${output} (${manifestServiceHostnames(manifest).length} service(s))`)
+}
+
+if (import.meta.main) {
+	await runZeropsCli(process.argv.slice(2)).catch((error: unknown) => {
+		console.error(error instanceof Error ? error.message : String(error))
+		process.exit(1)
+	})
+}

package/src/codec.ts

@@ -0,0 +1,50 @@
+import type { JsonValue, ProviderCodec } from '@fabrika/provider-contract'
+import type { ZeropsRuntimeTarget } from './types'
+
+const field = (payload: JsonValue, key: string): JsonValue | undefined => {
+	if (typeof payload !== 'object' || payload === null || Array.isArray(payload)) {
+		throw new Error('Zerops target must be an object')
+	}
+	return payload[key]
+}
+
+const requiredString = (payload: JsonValue, key: string): string => {
+	const value = field(payload, key)
+	if (typeof value !== 'string' || value === '') {
+		throw new Error(`Zerops target ${key} must be a non-empty string`)
+	}
+	return value
+}
+
+const optionalString = (payload: JsonValue, key: string): string | undefined => {
+	const value = field(payload, key)
+	if (value === undefined) {
+		return undefined
+	}
+	if (typeof value !== 'string' || value === '') {
+		throw new Error(`Zerops target ${key} must be a non-empty string when present`)
+	}
+	return value
+}
+
+export const zeropsTargetCodec: ProviderCodec<ZeropsRuntimeTarget> = {
+	version: 1,
+	encode: (target) => ({
+		projectId: target.projectId,
+		serviceId: target.serviceId,
+		accessToken: target.accessToken,
+		...(target.buildFromGit !== undefined ? { buildFromGit: target.buildFromGit } : {}),
+		...(target.apiBaseUrl !== undefined ? { apiBaseUrl: target.apiBaseUrl } : {}),
+		...(target.propustkaUrl !== undefined ? { propustkaUrl: target.propustkaUrl } : {}),
+		...(target.adminKey !== undefined ? { adminKey: target.adminKey } : {}),
+	}),
+	decode: (payload) => ({
+		projectId: requiredString(payload, 'projectId'),
+		serviceId: requiredString(payload, 'serviceId'),
+		accessToken: requiredString(payload, 'accessToken'),
+		...(optionalString(payload, 'buildFromGit') !== undefined ? { buildFromGit: optionalString(payload, 'buildFromGit') } : {}),
+		...(optionalString(payload, 'apiBaseUrl') !== undefined ? { apiBaseUrl: optionalString(payload, 'apiBaseUrl') } : {}),
+		...(optionalString(payload, 'propustkaUrl') !== undefined ? { propustkaUrl: optionalString(payload, 'propustkaUrl') } : {}),
+		...(optionalString(payload, 'adminKey') !== undefined ? { adminKey: optionalString(payload, 'adminKey') } : {}),
+	}),
+}

package/src/collaborators.ts

@@ -0,0 +1,47 @@
+import { reconcileSchema } from '@fabrika/auth'
+import type { SchemaReconciler } from '@fabrika/provider-contract'
+import { createZeropsApi, type ZeropsApi } from './api'
+import type { ZeropsRuntimeTarget } from './types'
+
+export type Sleeper = (ms: number, signal: AbortSignal) => Promise<void>
+
+export const defaultSleep: Sleeper = (ms, signal) =>
+	new Promise<void>((resolve) => {
+		if (signal.aborted) {
+			resolve()
+			return
+		}
+		const timer = setTimeout(() => {
+			signal.removeEventListener('abort', onAbort)
+			resolve()
+		}, ms)
+		const onAbort = (): void => {
+			clearTimeout(timer)
+			resolve()
+		}
+		signal.addEventListener('abort', onAbort, { once: true })
+	})
+
+export interface ZeropsCollaborators {
+	api: ZeropsApi
+	reconcileSchema: SchemaReconciler
+	sleep: Sleeper
+}
+
+export type ZeropsCollaboratorFactory = (target: ZeropsRuntimeTarget) => ZeropsCollaborators
+
+const defaultReconcileSchema: SchemaReconciler = (input) =>
+	reconcileSchema({
+		url: input.url,
+		app: input.app,
+		schema: input.schema,
+		...(input.returnOrigins === undefined ? {} : { returnOrigins: input.returnOrigins }),
+		adminKey: input.adminKey,
+		signal: input.signal,
+	})
+
+export const defaultZeropsCollaborators: ZeropsCollaboratorFactory = (target) => ({
+	api: createZeropsApi({ token: target.accessToken, baseUrl: target.apiBaseUrl }),
+	reconcileSchema: defaultReconcileSchema,
+	sleep: defaultSleep,
+})