@syncular/cli 0.0.0-44 → 0.0.0-48

package/src/commands/typegen.ts

@@ -1,406 +0,0 @@
-import { dirname, resolve } from 'node:path';
-import { pathToFileURL } from 'node:url';
-import type { ColumnCodecSource } from 'syncular/core';
-import type { DefinedMigrations } from 'syncular/migrations';
-import {
-  type GenerateTypesOptions,
-  generateTypes,
-  type SyncularImportType,
-  type TypegenDialect,
-} from 'syncular/typegen';
-import { printError, printInfo } from '../output';
-import { resolveDefaultSyncularConfigPath } from '../paths';
-
-type GenericDb = Record<string, never>;
-
-interface SyncConfigLike {
-  codecs?: ColumnCodecSource;
-}
-
-interface TypegenConfigLike {
-  output?: string;
-  dialect?: TypegenDialect;
-  extendsSyncClientDb?: boolean;
-  includeVersionHistory?: boolean;
-  tables?: string[];
-  syncularImportType?: SyncularImportType;
-  codecs?: ColumnCodecSource;
-}
-
-interface SyncularConfigLike {
-  migrations?: DefinedMigrations<GenericDb>;
-  sync?: SyncConfigLike;
-  typegen?: TypegenConfigLike;
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null;
-}
-
-function isColumnCodecSource(value: unknown): value is ColumnCodecSource {
-  return typeof value === 'function';
-}
-
-function isDefinedMigrationsShape(
-  value: unknown
-): value is DefinedMigrations<GenericDb> {
-  if (!isRecord(value)) {
-    return false;
-  }
-
-  const currentVersion = value.currentVersion;
-  const migrations = value.migrations;
-  const getMigration = value.getMigration;
-  if (
-    typeof currentVersion !== 'number' ||
-    !Number.isInteger(currentVersion) ||
-    currentVersion < 0 ||
-    !Array.isArray(migrations) ||
-    typeof getMigration !== 'function'
-  ) {
-    return false;
-  }
-
-  return migrations.every((migration) => {
-    if (!isRecord(migration)) {
-      return false;
-    }
-    const version = migration.version;
-    const name = migration.name;
-    const up = migration.up;
-    const down = migration.down;
-    return (
-      typeof version === 'number' &&
-      Number.isInteger(version) &&
-      version > 0 &&
-      typeof name === 'string' &&
-      typeof up === 'function' &&
-      (down === undefined || typeof down === 'function')
-    );
-  });
-}
-
-function isTypegenDialect(value: unknown): value is TypegenDialect {
-  return value === 'sqlite' || value === 'postgres';
-}
-
-function isSyncularImportType(value: unknown): value is SyncularImportType {
-  if (value === 'scoped' || value === 'umbrella') {
-    return true;
-  }
-  if (!isRecord(value)) {
-    return false;
-  }
-  const clientValue = value.client;
-  if (typeof clientValue !== 'string' || clientValue.trim().length === 0) {
-    return false;
-  }
-  return Object.values(value).every(
-    (entry) => typeof entry === 'string' && entry.trim().length > 0
-  );
-}
-
-function isStringArray(value: unknown): value is string[] {
-  return (
-    Array.isArray(value) &&
-    value.every((entry) => typeof entry === 'string' && entry.trim().length > 0)
-  );
-}
-
-function isBoolean(value: unknown): value is boolean {
-  return typeof value === 'boolean';
-}
-
-function parseBooleanFlag(
-  flagValues: Map<string, string>,
-  flag: string,
-  fallback: boolean | null
-): boolean | null {
-  const raw = flagValues.get(flag);
-  if (!raw) {
-    return fallback;
-  }
-
-  const value = raw.trim().toLowerCase();
-  if (value === '1' || value === 'true' || value === 'yes' || value === 'on') {
-    return true;
-  }
-  if (value === '0' || value === 'false' || value === 'no' || value === 'off') {
-    return false;
-  }
-
-  throw new Error(
-    `Invalid ${flag} value "${raw}". Use true/false, yes/no, on/off, or 1/0.`
-  );
-}
-
-function parseCsvFlag(
-  flagValues: Map<string, string>,
-  flag: string
-): string[] | null {
-  const raw = flagValues.get(flag)?.trim();
-  if (!raw) {
-    return null;
-  }
-  const values = raw
-    .split(',')
-    .map((entry) => entry.trim())
-    .filter((entry) => entry.length > 0);
-  if (values.length === 0) {
-    throw new Error(`Invalid ${flag}: expected a non-empty CSV list.`);
-  }
-  return values;
-}
-
-function parseConfigValue(
-  configPath: string,
-  value: unknown
-): SyncularConfigLike {
-  if (!isRecord(value)) {
-    throw new Error(`Config default export must be an object (${configPath}).`);
-  }
-
-  const config: SyncularConfigLike = {};
-
-  const migrationsValue = value.migrations;
-  if (!isDefinedMigrationsShape(migrationsValue)) {
-    throw new Error(
-      `Config is missing a valid "migrations" export (${configPath}).`
-    );
-  }
-  config.migrations = migrationsValue;
-
-  const syncValue = value.sync;
-  if (syncValue !== undefined) {
-    if (!isRecord(syncValue)) {
-      throw new Error(`Config field "sync" must be an object (${configPath}).`);
-    }
-    const codecsValue = syncValue.codecs;
-    if (codecsValue !== undefined && !isColumnCodecSource(codecsValue)) {
-      throw new Error(
-        `Config field "sync.codecs" must be a function when provided (${configPath}).`
-      );
-    }
-    config.sync = {
-      codecs: codecsValue,
-    };
-  }
-
-  const typegenValue = value.typegen;
-  if (typegenValue !== undefined) {
-    if (!isRecord(typegenValue)) {
-      throw new Error(
-        `Config field "typegen" must be an object when provided (${configPath}).`
-      );
-    }
-
-    const output = typegenValue.output;
-    if (output !== undefined && typeof output !== 'string') {
-      throw new Error(
-        `Config field "typegen.output" must be a string (${configPath}).`
-      );
-    }
-
-    const dialect = typegenValue.dialect;
-    if (dialect !== undefined && !isTypegenDialect(dialect)) {
-      throw new Error(
-        `Config field "typegen.dialect" must be sqlite or postgres (${configPath}).`
-      );
-    }
-
-    const includeVersionHistory = typegenValue.includeVersionHistory;
-    if (
-      includeVersionHistory !== undefined &&
-      !isBoolean(includeVersionHistory)
-    ) {
-      throw new Error(
-        `Config field "typegen.includeVersionHistory" must be boolean (${configPath}).`
-      );
-    }
-
-    const extendsSyncClientDb = typegenValue.extendsSyncClientDb;
-    if (extendsSyncClientDb !== undefined && !isBoolean(extendsSyncClientDb)) {
-      throw new Error(
-        `Config field "typegen.extendsSyncClientDb" must be boolean (${configPath}).`
-      );
-    }
-
-    const tables = typegenValue.tables;
-    if (tables !== undefined && !isStringArray(tables)) {
-      throw new Error(
-        `Config field "typegen.tables" must be a non-empty string array (${configPath}).`
-      );
-    }
-
-    const syncularImportType = typegenValue.syncularImportType;
-    if (
-      syncularImportType !== undefined &&
-      !isSyncularImportType(syncularImportType)
-    ) {
-      throw new Error(
-        `Config field "typegen.syncularImportType" is invalid (${configPath}).`
-      );
-    }
-
-    const codecs = typegenValue.codecs;
-    if (codecs !== undefined && !isColumnCodecSource(codecs)) {
-      throw new Error(
-        `Config field "typegen.codecs" must be a function (${configPath}).`
-      );
-    }
-
-    config.typegen = {
-      output,
-      dialect,
-      includeVersionHistory,
-      extendsSyncClientDb,
-      tables,
-      syncularImportType,
-      codecs,
-    };
-  }
-
-  return config;
-}
-
-async function loadSyncularConfig(
-  configPath: string
-): Promise<SyncularConfigLike> {
-  const resolvedConfigPath = resolve(configPath);
-  const configUrl = new URL(pathToFileURL(resolvedConfigPath).href);
-  configUrl.searchParams.set('t', String(Date.now()));
-
-  let moduleValue: Record<string, unknown>;
-  try {
-    const imported = await import(configUrl.href);
-    if (!isRecord(imported)) {
-      throw new Error('Module did not load as an object');
-    }
-    moduleValue = imported;
-  } catch (error: unknown) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(
-      `Failed to import config module (${resolvedConfigPath}): ${message}`
-    );
-  }
-
-  return parseConfigValue(resolvedConfigPath, moduleValue.default);
-}
-
-function resolveConfigPath(flagValues: Map<string, string>): string {
-  const raw = flagValues.get('--config')?.trim();
-  if (raw && raw.length > 0) {
-    return resolve(process.cwd(), raw);
-  }
-  return resolveDefaultSyncularConfigPath(process.cwd());
-}
-
-function resolveDialect(args: {
-  flagValues: Map<string, string>;
-  config: SyncularConfigLike;
-}): TypegenDialect {
-  const fromFlag = args.flagValues.get('--dialect')?.trim();
-  if (fromFlag) {
-    if (!isTypegenDialect(fromFlag)) {
-      throw new Error(
-        `Invalid --dialect value "${fromFlag}". Use sqlite or postgres.`
-      );
-    }
-    return fromFlag;
-  }
-
-  return args.config.typegen?.dialect ?? 'sqlite';
-}
-
-function resolveOutputPath(args: {
-  flagValues: Map<string, string>;
-  configPath: string;
-  config: SyncularConfigLike;
-}): string {
-  const fromFlag = args.flagValues.get('--out')?.trim();
-  const fromConfig = args.config.typegen?.output?.trim();
-  const rawOutput = fromFlag || fromConfig || './src/types.generated.ts';
-  return resolve(dirname(args.configPath), rawOutput);
-}
-
-function resolveSyncularImportType(args: {
-  flagValues: Map<string, string>;
-  config: SyncularConfigLike;
-}): SyncularImportType {
-  const fromFlag = args.flagValues.get('--syncular-import-type')?.trim();
-  if (fromFlag) {
-    if (fromFlag !== 'scoped' && fromFlag !== 'umbrella') {
-      throw new Error(
-        `Invalid --syncular-import-type "${fromFlag}". Use scoped or umbrella.`
-      );
-    }
-    return fromFlag;
-  }
-  return args.config.typegen?.syncularImportType ?? 'umbrella';
-}
-
-export async function runTypegen(
-  flagValues: Map<string, string>
-): Promise<number> {
-  try {
-    const configPath = resolveConfigPath(flagValues);
-    const config = await loadSyncularConfig(configPath);
-    const migrations = config.migrations;
-    if (!migrations) {
-      throw new Error(
-        `Config is missing a valid "migrations" export (${configPath}).`
-      );
-    }
-
-    const outputPath = resolveOutputPath({
-      flagValues,
-      configPath,
-      config,
-    });
-    const dialect = resolveDialect({ flagValues, config });
-
-    const configTables = config.typegen?.tables;
-    const flagTables = parseCsvFlag(flagValues, '--tables');
-    const tables = flagTables ?? configTables;
-
-    const includeVersionHistory = parseBooleanFlag(
-      flagValues,
-      '--include-version-history',
-      config.typegen?.includeVersionHistory ?? false
-    );
-    const extendsSyncClientDb = parseBooleanFlag(
-      flagValues,
-      '--extends-sync-client-db',
-      config.typegen?.extendsSyncClientDb ?? true
-    );
-    const syncularImportType = resolveSyncularImportType({
-      flagValues,
-      config,
-    });
-    const codecs = config.typegen?.codecs ?? config.sync?.codecs ?? undefined;
-
-    const options: GenerateTypesOptions<GenericDb> = {
-      migrations,
-      output: outputPath,
-      dialect,
-      extendsSyncClientDb: extendsSyncClientDb ?? true,
-      includeVersionHistory: includeVersionHistory ?? false,
-      syncularImportType,
-      tables,
-      codecs,
-    };
-
-    const result = await generateTypes(options);
-    printInfo('Type generation completed.');
-    console.log(`Config: ${configPath}`);
-    console.log(`Output: ${result.outputPath}`);
-    console.log(`Schema version: ${result.currentVersion}`);
-    console.log(`Tables: ${result.tableCount}`);
-    return 0;
-  } catch (error: unknown) {
-    printError(
-      error instanceof Error ? error.message : 'Type generation failed.'
-    );
-    return 1;
-  }
-}

package/src/constants.ts

@@ -1,4 +0,0 @@
-import process from 'node:process';
-
-export const CLI_VERSION = process.env.npm_package_version ?? '0.0.0';
-export const CLI_NAME = 'syncular';

package/src/control-plane.ts

@@ -1,23 +0,0 @@
-export function normalizeControlPlaneBaseUrl(raw: string): string {
-  const trimmed = raw.trim();
-  if (trimmed.length === 0) {
-    return trimmed;
-  }
-
-  try {
-    const parsed = new URL(trimmed);
-    const normalizedPath = parsed.pathname.replace(/\/+$/, '');
-    if (normalizedPath === '' || normalizedPath === '/') {
-      parsed.pathname = '/api/control';
-    } else if (normalizedPath === '/api') {
-      parsed.pathname = '/api/control';
-    } else {
-      parsed.pathname = normalizedPath;
-    }
-    parsed.search = '';
-    parsed.hash = '';
-    return parsed.toString().replace(/\/$/, '');
-  } catch {
-    return trimmed.replace(/\/$/, '');
-  }
-}