@syncular/cli 0.0.0-44

package/src/targets/state.ts

@@ -0,0 +1,99 @@
+import { existsSync } from 'node:fs';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { resolveDefaultSyncularConfigPath } from '../paths';
+import type { TargetId } from './types';
+import { TARGET_IDS } from './types';
+
+const TARGET_STATE_RELATIVE_PATH = '.syncular/target.json';
+const DEFAULT_TARGET_ID: TargetId = 'spaces';
+
+interface StoredTargetState {
+  target: TargetId;
+}
+
+export function listTargetIds(): readonly TargetId[] {
+  return TARGET_IDS;
+}
+
+export function isTargetId(value: string): value is TargetId {
+  return TARGET_IDS.includes(value as TargetId);
+}
+
+export function resolveTargetStatePath(cwd: string): string {
+  return resolve(cwd, TARGET_STATE_RELATIVE_PATH);
+}
+
+export async function readStoredTargetId(
+  cwd: string
+): Promise<TargetId | null> {
+  const statePath = resolveTargetStatePath(cwd);
+  if (!existsSync(statePath)) {
+    return null;
+  }
+
+  try {
+    const raw = await readFile(statePath, 'utf8');
+    const parsed = JSON.parse(raw) as Partial<StoredTargetState>;
+    if (typeof parsed.target !== 'string' || !isTargetId(parsed.target)) {
+      return null;
+    }
+    return parsed.target;
+  } catch {
+    return null;
+  }
+}
+
+export async function writeStoredTargetId(args: {
+  cwd: string;
+  targetId: TargetId;
+}): Promise<string> {
+  const statePath = resolveTargetStatePath(args.cwd);
+  await mkdir(resolve(args.cwd, '.syncular'), { recursive: true });
+  await writeFile(
+    statePath,
+    `${JSON.stringify({ target: args.targetId } satisfies StoredTargetState, null, 2)}\n`,
+    'utf8'
+  );
+  return statePath;
+}
+
+export async function resolveEffectiveTargetId(args: {
+  cwd: string;
+  explicitTargetId: string | null;
+}): Promise<{
+  source: 'flag' | 'state' | 'default';
+  targetId: TargetId;
+}> {
+  if (args.explicitTargetId) {
+    if (!isTargetId(args.explicitTargetId)) {
+      throw new Error(
+        `Unsupported --target "${args.explicitTargetId}". Supported targets: ${TARGET_IDS.join(', ')}.`
+      );
+    }
+    return {
+      source: 'flag',
+      targetId: args.explicitTargetId,
+    };
+  }
+
+  const storedTargetId = await readStoredTargetId(args.cwd);
+  if (storedTargetId) {
+    return {
+      source: 'state',
+      targetId: storedTargetId,
+    };
+  }
+
+  return {
+    source: 'default',
+    targetId: DEFAULT_TARGET_ID,
+  };
+}
+
+export function resolveTargetDefaultConfigPath(args: {
+  cwd: string;
+  targetId: TargetId;
+}): string {
+  return resolveDefaultSyncularConfigPath(args.cwd);
+}

package/src/targets/types.ts

@@ -0,0 +1,8 @@
+export const TARGET_IDS = ['spaces'] as const;
+export type TargetId = (typeof TARGET_IDS)[number];
+
+export interface TargetDefinition {
+  id: TargetId;
+  description: string;
+  defaultBuildpackId: 'contract-worker';
+}

package/src/templates/index.ts

@@ -0,0 +1,2 @@
+export * from './registry';
+export * from './syncular-types';

package/src/templates/registry.ts

@@ -0,0 +1,42 @@
+import { TEMPLATE_EXTENSION_MANIFEST } from '../extensions';
+
+type TemplateManifest = typeof TEMPLATE_EXTENSION_MANIFEST;
+function buildTemplateRegistry(manifest: TemplateManifest) {
+  const entries = Object.entries(manifest);
+  const seenTemplateIds = new Set<string>();
+
+  for (const [registryKey, manifestEntry] of entries) {
+    const templateId = manifestEntry.template.id;
+    if (templateId.length === 0) {
+      throw new Error(`Template "${registryKey}" has an empty id.`);
+    }
+
+    if (seenTemplateIds.has(templateId)) {
+      throw new Error(`Duplicate template id in manifest: "${templateId}".`);
+    }
+    seenTemplateIds.add(templateId);
+  }
+
+  return Object.freeze(
+    Object.fromEntries(
+      entries.map(([registryKey, manifestEntry]) => [
+        registryKey,
+        manifestEntry.template,
+      ])
+    )
+  ) as {
+    [K in keyof TemplateManifest]: TemplateManifest[K]['template'];
+  };
+}
+
+export const templateRegistry = buildTemplateRegistry(
+  TEMPLATE_EXTENSION_MANIFEST
+);
+
+const TEMPLATE_IDS = Object.freeze(
+  Object.values(templateRegistry).map((template) => template.id)
+) as readonly string[];
+
+export function listTemplateIds(): readonly string[] {
+  return TEMPLATE_IDS;
+}

package/src/templates/syncular-types.ts

@@ -0,0 +1,10 @@
+export type {
+  SyncularClientDialect,
+  SyncularElectronDialect,
+  SyncularLibrariesTarget,
+  SyncularServerDialect,
+} from '@syncular/cli-template-syncular-libraries';
+export {
+  DEFAULT_SYNCULAR_LIBRARIES_TARGETS,
+  SYNCULAR_LIBRARIES_TARGETS,
+} from '@syncular/cli-template-syncular-libraries';

package/src/types.ts

@@ -0,0 +1,67 @@
+export type RootCommand =
+  | 'help'
+  | 'version'
+  | 'doctor'
+  | 'console'
+  | 'login'
+  | 'logout'
+  | 'whoami'
+  | 'create-space'
+  | 'create'
+  | 'dev'
+  | 'typegen'
+  | 'migrate-status'
+  | 'migrate-up'
+  | 'build'
+  | 'eject'
+  | 'target'
+  | 'deploy'
+  | 'verify'
+  | 'rollback'
+  | 'deployments'
+  | 'interactive';
+
+export interface ParsedArgs {
+  command: RootCommand | null;
+  subcommand: string | null;
+  flags: Set<string>;
+  flagValues: Map<string, string>;
+  positionals: string[];
+}
+
+export interface InteractiveField {
+  id: string;
+  label: string;
+  kind?: 'string' | 'number' | 'boolean';
+  placeholder?: string;
+  required?: boolean;
+  defaultValue?: string;
+}
+
+export interface InteractiveCommand {
+  id:
+    | 'doctor'
+    | 'console'
+    | 'create'
+    | 'create-space'
+    | 'dev'
+    | 'typegen'
+    | 'migrate-status'
+    | 'migrate-up'
+    | 'build'
+    | 'eject'
+    | 'target'
+    | 'deploy'
+    | 'verify'
+    | 'deployments'
+    | 'rollback'
+    | 'login'
+    | 'logout'
+    | 'whoami'
+    | 'help'
+    | 'quit';
+  label: string;
+  description: string;
+  fields?: InteractiveField[];
+  buildArgv(values: Record<string, string>): string[] | null;
+}