@lorion-org/nuxt 1.0.0-beta.1 → 1.0.0-beta.2

package/src/runtime-config-node.ts

@@ -0,0 +1,66 @@
+import {
+  loadRuntimeConfigSourceTree,
+  resolveRuntimeConfigSourcePublicRootPath,
+  validateRuntimeConfigSourceScopes,
+  type RuntimeConfigSchemaTargetInput,
+  type RuntimeConfigValidateResult,
+  type ValidateRuntimeConfigPatternSourceScopesOptions,
+} from '@lorion-org/runtime-config-node';
+import { toRuntimeConfigFragment, type RuntimeConfigFragmentMap } from '@lorion-org/runtime-config';
+import { createNuxtRuntimeConfig } from './runtime-config';
+import type {
+  CreateNuxtRuntimeConfigOptions,
+  NuxtRuntimeConfig,
+  RuntimeConfigNuxtSourceOptions,
+} from './types';
+export type { RuntimeConfigNuxtSourceOptions } from './types';
+
+export type CreateNuxtRuntimeConfigFromSourceOptions = Omit<
+  CreateNuxtRuntimeConfigOptions,
+  'fragments' | 'runtimeConfig'
+>;
+
+export type ValidateNuxtRuntimeConfigSourceScopesOptions = Omit<
+  ValidateRuntimeConfigPatternSourceScopesOptions,
+  'fileName' | 'runtimeConfigDirName'
+>;
+
+export function resolveNuxtRuntimeConfigPublicRootPath(
+  source: RuntimeConfigNuxtSourceOptions,
+): string | undefined {
+  return resolveRuntimeConfigSourcePublicRootPath(source);
+}
+
+export function loadNuxtRuntimeConfigFragments(
+  source: RuntimeConfigNuxtSourceOptions,
+  options: Pick<CreateNuxtRuntimeConfigOptions, 'contextInputKey'> = {},
+): RuntimeConfigFragmentMap {
+  const fragments = loadRuntimeConfigSourceTree(source);
+  const normalizedFragments: RuntimeConfigFragmentMap = new Map();
+
+  for (const [scopeId, config] of fragments.entries()) {
+    normalizedFragments.set(scopeId, toRuntimeConfigFragment(config, options));
+  }
+
+  return normalizedFragments;
+}
+
+export function createNuxtRuntimeConfigFromSource(
+  source: RuntimeConfigNuxtSourceOptions,
+  options: CreateNuxtRuntimeConfigFromSourceOptions = {},
+): NuxtRuntimeConfig {
+  return createNuxtRuntimeConfig({
+    ...options,
+    fragments: loadNuxtRuntimeConfigFragments(source, {
+      ...(options.contextInputKey ? { contextInputKey: options.contextInputKey } : {}),
+    }),
+  });
+}
+
+export function validateNuxtRuntimeConfigSourceScopes(
+  source: RuntimeConfigNuxtSourceOptions,
+  targets: RuntimeConfigSchemaTargetInput[],
+  options: ValidateNuxtRuntimeConfigSourceScopesOptions = {},
+): RuntimeConfigValidateResult {
+  return validateRuntimeConfigSourceScopes(source, targets, options);
+}

package/src/runtime-config.ts

@@ -0,0 +1,292 @@
+import {
+  getPrivateRuntimeConfigScope,
+  getPublicRuntimeConfigScope,
+  getRuntimeConfigFragment,
+  getRuntimeConfigScope,
+  projectSectionedRuntimeConfig,
+  resolveRuntimeConfigValueFromRuntimeConfig,
+  toRuntimeConfigFragment,
+  type GetRuntimeConfigFragmentOptions,
+  type GetRuntimeConfigScopeOptions,
+  type ResolveRuntimeConfigValueFromRuntimeConfigOptions,
+  type NamedRuntimeConfigFragment,
+  type RuntimeConfigContext,
+  type RuntimeConfigFragmentMap,
+  type RuntimeConfigSection,
+  type SectionedRuntimeConfig,
+} from '@lorion-org/runtime-config';
+import type {
+  CreateNuxtRuntimeConfigOptions,
+  NuxtExtensionSelection,
+  NuxtPrivateRuntimeConfigMode,
+  NuxtProviderSelectionRuntimeConfig,
+  NuxtRuntimeConfig,
+  NuxtRuntimeConfigInput,
+  ReadNuxtRuntimeConfigOptions,
+  RuntimeConfigNuxtFragments,
+} from './types';
+export type {
+  CreateNuxtRuntimeConfigOptions,
+  NuxtExtensionSelection,
+  NuxtExtensionSelectionRuntimeConfig,
+  NuxtPrivateRuntimeConfigMode,
+  NuxtRuntimeConfig,
+  NuxtRuntimeConfigInput,
+  ReadNuxtRuntimeConfigOptions,
+  RuntimeConfigNuxtFragments,
+} from './types';
+
+const isObject = (value: unknown): value is Record<string, unknown> => {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+};
+
+const toStringArray = (value: unknown): string[] =>
+  Array.isArray(value) ? value.filter((entry): entry is string => typeof entry === 'string') : [];
+
+function createContextInputOptions(
+  contextInputKey?: string,
+): Pick<CreateNuxtRuntimeConfigOptions, 'contextInputKey'> {
+  return contextInputKey === undefined ? {} : { contextInputKey };
+}
+
+function createPrivateOutputOptions(
+  privateOutput?: NuxtPrivateRuntimeConfigMode,
+): Pick<CreateNuxtRuntimeConfigOptions, 'privateOutput'> {
+  return privateOutput === undefined ? {} : { privateOutput };
+}
+
+function createPrivateInputOptions(
+  privateInput?: NuxtPrivateRuntimeConfigMode,
+): ReadNuxtRuntimeConfigOptions {
+  return privateInput === undefined ? {} : { privateInput };
+}
+
+function withoutPublicRuntimeConfig(config: NuxtRuntimeConfigInput): RuntimeConfigSection {
+  const privateConfig = { ...config };
+  delete privateConfig.public;
+
+  return privateConfig;
+}
+
+export function normalizeNuxtRuntimeConfigFragments(
+  fragments: RuntimeConfigNuxtFragments = {},
+  options: Pick<CreateNuxtRuntimeConfigOptions, 'contextInputKey'> = {},
+): NamedRuntimeConfigFragment[] | RuntimeConfigFragmentMap {
+  if (fragments instanceof Map) {
+    const normalizedFragments: RuntimeConfigFragmentMap = new Map();
+
+    for (const [scopeId, config] of fragments.entries()) {
+      normalizedFragments.set(scopeId, toRuntimeConfigFragment(config, options));
+    }
+
+    return normalizedFragments;
+  }
+
+  if (Array.isArray(fragments)) {
+    return fragments.map((fragment) => ({
+      scopeId: fragment.scopeId,
+      config: toRuntimeConfigFragment(fragment.config, options),
+    }));
+  }
+
+  return Object.entries(fragments).map(([scopeId, config]) => ({
+    scopeId,
+    config: toRuntimeConfigFragment(config, options),
+  }));
+}
+
+export function toNuxtRuntimeConfig(
+  runtimeConfig: SectionedRuntimeConfig,
+  options: Pick<CreateNuxtRuntimeConfigOptions, 'privateOutput'> = {},
+): NuxtRuntimeConfig {
+  if (options.privateOutput === 'section') {
+    return {
+      private: {
+        ...runtimeConfig.private,
+      },
+      public: {
+        ...runtimeConfig.public,
+      },
+    };
+  }
+
+  return {
+    ...runtimeConfig.private,
+    public: {
+      ...runtimeConfig.public,
+    },
+  };
+}
+
+export function fromNuxtRuntimeConfig(
+  runtimeConfig: NuxtRuntimeConfigInput,
+  options: ReadNuxtRuntimeConfigOptions = {},
+): SectionedRuntimeConfig {
+  if (options.privateInput === 'section') {
+    return {
+      public: isObject(runtimeConfig.public) ? runtimeConfig.public : {},
+      private: isObject(runtimeConfig.private) ? runtimeConfig.private : {},
+    };
+  }
+
+  const { public: publicConfig = {}, ...privateConfig } = runtimeConfig;
+
+  return {
+    public: publicConfig,
+    private: privateConfig,
+  };
+}
+
+export function createNuxtRuntimeConfig(
+  options: CreateNuxtRuntimeConfigOptions = {},
+): NuxtRuntimeConfig {
+  const { contextInputKey, fragments, runtimeConfig, ...projectOptions } = options;
+  const runtimeConfigFragments = fragments ?? {};
+  const sectionedRuntimeConfig =
+    runtimeConfig ??
+    projectSectionedRuntimeConfig(
+      normalizeNuxtRuntimeConfigFragments(
+        runtimeConfigFragments,
+        createContextInputOptions(contextInputKey),
+      ),
+      projectOptions,
+    );
+
+  return toNuxtRuntimeConfig(
+    sectionedRuntimeConfig,
+    createPrivateOutputOptions(options.privateOutput),
+  );
+}
+
+export function mergeNuxtRuntimeConfig(
+  target: NuxtRuntimeConfigInput = {},
+  source: NuxtRuntimeConfigInput = {},
+): NuxtRuntimeConfig {
+  const targetPublic = isObject(target.public) ? target.public : {};
+  const sourcePublic = isObject(source.public) ? source.public : {};
+
+  return {
+    ...withoutPublicRuntimeConfig(target),
+    ...withoutPublicRuntimeConfig(source),
+    public: {
+      ...targetPublic,
+      ...sourcePublic,
+    },
+  };
+}
+
+export function getNuxtExtensionSelection(
+  runtimeConfig: NuxtRuntimeConfigInput,
+): NuxtExtensionSelection {
+  const selection = isObject(runtimeConfig.public?.extensionSelection)
+    ? runtimeConfig.public.extensionSelection
+    : undefined;
+
+  if (!selection) {
+    return {
+      discoveredExtensionIds: [],
+      notInjectedExtensionIds: [],
+      resolvedExtensionIds: [],
+      selectedExtensionIds: [],
+    };
+  }
+
+  const discoveredExtensionIds = toStringArray(selection.discoveredExtensionIds);
+  const resolvedExtensionIds = toStringArray(selection.resolvedExtensionIds);
+  const resolvedExtensionIdSet = new Set(resolvedExtensionIds);
+
+  return {
+    discoveredExtensionIds,
+    notInjectedExtensionIds: discoveredExtensionIds
+      .filter((id) => !resolvedExtensionIdSet.has(id))
+      .sort((left, right) => left.localeCompare(right)),
+    resolvedExtensionIds,
+    selectedExtensionIds: toStringArray(selection.selectedExtensionIds),
+  };
+}
+
+export function getNuxtProviderSelection(
+  runtimeConfig: NuxtRuntimeConfigInput,
+): NuxtProviderSelectionRuntimeConfig | undefined {
+  const providerSelection = runtimeConfig.public?.providerSelection;
+
+  return isObject(providerSelection) && isObject(providerSelection.selections)
+    ? (providerSelection as NuxtProviderSelectionRuntimeConfig)
+    : undefined;
+}
+
+export function getPublicNuxtRuntimeConfigScope<
+  T extends RuntimeConfigSection = RuntimeConfigSection,
+>(
+  runtimeConfig: NuxtRuntimeConfigInput,
+  scopeId: string,
+  options: Omit<GetRuntimeConfigScopeOptions, 'visibility'> & ReadNuxtRuntimeConfigOptions = {},
+): T {
+  const { privateInput, ...scopeOptions } = options;
+
+  return getPublicRuntimeConfigScope<T>(
+    fromNuxtRuntimeConfig(runtimeConfig, createPrivateInputOptions(privateInput)),
+    scopeId,
+    scopeOptions,
+  );
+}
+
+export function getNuxtRuntimeConfigScope<T extends RuntimeConfigSection = RuntimeConfigSection>(
+  runtimeConfig: NuxtRuntimeConfigInput,
+  scopeId: string,
+  options: GetRuntimeConfigScopeOptions & ReadNuxtRuntimeConfigOptions = {},
+): T {
+  const { privateInput, ...scopeOptions } = options;
+
+  return getRuntimeConfigScope<T>(
+    fromNuxtRuntimeConfig(runtimeConfig, createPrivateInputOptions(privateInput)),
+    scopeId,
+    scopeOptions,
+  );
+}
+
+export function getPrivateNuxtRuntimeConfigScope<
+  T extends RuntimeConfigSection = RuntimeConfigSection,
+>(
+  runtimeConfig: NuxtRuntimeConfigInput,
+  scopeId: string,
+  options: Omit<GetRuntimeConfigScopeOptions, 'visibility'> & ReadNuxtRuntimeConfigOptions = {},
+): T {
+  const { privateInput, ...scopeOptions } = options;
+
+  return getPrivateRuntimeConfigScope<T>(
+    fromNuxtRuntimeConfig(runtimeConfig, createPrivateInputOptions(privateInput)),
+    scopeId,
+    scopeOptions,
+  );
+}
+
+export function resolveNuxtRuntimeConfigValue<T = unknown>(
+  runtimeConfig: NuxtRuntimeConfigInput,
+  scopeId: string,
+  key: string,
+  options: ResolveRuntimeConfigValueFromRuntimeConfigOptions<T> & ReadNuxtRuntimeConfigOptions = {},
+): T | undefined {
+  const { privateInput, ...resolveOptions } = options;
+
+  return resolveRuntimeConfigValueFromRuntimeConfig<T>(
+    fromNuxtRuntimeConfig(runtimeConfig, createPrivateInputOptions(privateInput)),
+    scopeId,
+    key,
+    resolveOptions,
+  );
+}
+
+export function getNuxtRuntimeConfigFragment(
+  runtimeConfig: NuxtRuntimeConfigInput,
+  scopeId: string,
+  options: GetRuntimeConfigFragmentOptions & ReadNuxtRuntimeConfigOptions = {},
+): RuntimeConfigContext {
+  const { privateInput, ...fragmentOptions } = options;
+
+  return getRuntimeConfigFragment(
+    fromNuxtRuntimeConfig(runtimeConfig, createPrivateInputOptions(privateInput)),
+    scopeId,
+    fragmentOptions,
+  );
+}

package/src/types.ts

@@ -0,0 +1,143 @@
+import type {
+  NamedRuntimeConfigFragment,
+  ProjectSectionedRuntimeConfigOptions,
+  RuntimeConfigFragment,
+  RuntimeConfigFragmentMap,
+  RuntimeConfigSection,
+  SectionedRuntimeConfig,
+} from '@lorion-org/runtime-config';
+import type { ProviderPreferenceMap, ProviderSelection } from '@lorion-org/provider-selection';
+import type {
+  Descriptor,
+  DescriptorSelectionSeedInput,
+  RelationDescriptor,
+} from '@lorion-org/composition-graph';
+import type {
+  RuntimeConfigPathPatternSource,
+  ValidateRuntimeConfigPatternSourceScopesOptions,
+} from '@lorion-org/runtime-config-node';
+import type { JsonSchemaObject } from './descriptor-schema';
+import type { NuxtExtensionBootstrap } from './extensions';
+
+export type RuntimeConfigNuxtFragmentInput = RuntimeConfigFragment & Record<string, unknown>;
+
+export type RuntimeConfigNuxtFragments =
+  | RuntimeConfigFragmentMap
+  | NamedRuntimeConfigFragment[]
+  | Record<string, RuntimeConfigNuxtFragmentInput>;
+
+export type RuntimeConfigNuxtSourceOptions = RuntimeConfigPathPatternSource;
+
+export type NuxtPrivateRuntimeConfigMode = 'root' | 'section';
+
+export type NuxtRuntimeConfig = RuntimeConfigSection & {
+  public: RuntimeConfigSection;
+};
+
+export type NuxtRuntimeConfigInput = RuntimeConfigSection & {
+  public?: RuntimeConfigSection;
+};
+
+export type CreateNuxtRuntimeConfigOptions = ProjectSectionedRuntimeConfigOptions & {
+  contextInputKey?: string;
+  fragments?: RuntimeConfigNuxtFragments;
+  privateOutput?: NuxtPrivateRuntimeConfigMode;
+  runtimeConfig?: SectionedRuntimeConfig;
+};
+
+export type ReadNuxtRuntimeConfigOptions = {
+  privateInput?: NuxtPrivateRuntimeConfigMode;
+};
+
+export type RuntimeConfigNuxtModuleOptions = Omit<CreateNuxtRuntimeConfigOptions, 'scopeIds'> & {
+  enabled?: boolean;
+  imports?: boolean;
+  publicAssets?:
+    | boolean
+    | {
+        maxAge?: number;
+      };
+  source?: RuntimeConfigNuxtSourceOptions;
+  validation?: false | NuxtRuntimeConfigValidationOptions;
+};
+
+export type NuxtRuntimeConfigValidationOptions = Pick<
+  ValidateRuntimeConfigPatternSourceScopesOptions,
+  'formatError' | 'schemaFileName'
+>;
+
+export type NuxtProviderSelectionModuleOptions = {
+  configuredProviders?: ProviderPreferenceMap;
+  enabled?: boolean;
+  fallbackProviders?: ProviderPreferenceMap;
+  selectedProviders?: ProviderPreferenceMap;
+};
+
+export type NuxtProviderSelectionRuntimeConfig = {
+  configuredProviders: ProviderPreferenceMap;
+  excludedProviderIds: string[];
+  fallbackProviders: ProviderPreferenceMap;
+  mismatches: Array<{
+    capabilityId: string;
+    configuredProviderId: string;
+  }>;
+  selections: Record<string, ProviderSelection>;
+};
+
+export type NuxtExtensionSelectionRuntimeConfig = {
+  discoveredExtensionIds: string[];
+  resolvedExtensionIds: string[];
+  selectedExtensionIds: string[];
+};
+
+export type NuxtExtensionSelection = NuxtExtensionSelectionRuntimeConfig & {
+  notInjectedExtensionIds: string[];
+};
+
+export type NuxtExtensionBootstrapLogEvent = {
+  bootstrap: NuxtExtensionBootstrap;
+  providerSelection?: NuxtProviderSelectionRuntimeConfig;
+};
+
+export type NuxtExtensionBootstrapReporter = (event: NuxtExtensionBootstrapLogEvent) => void;
+
+export type NuxtBaseExtensionSelectionInput = {
+  descriptors: Descriptor[];
+  selectedExtensions: string[];
+};
+
+export type NuxtBaseExtensionSelection =
+  | string
+  | string[]
+  | ((input: NuxtBaseExtensionSelectionInput) => string[]);
+
+export type NuxtExtensionSelectionSeedOptions = Omit<DescriptorSelectionSeedInput, 'defaultValue'>;
+
+export type NuxtExtensionModuleOptions = {
+  baseExtensions?: NuxtBaseExtensionSelection;
+  defaultSelection?: string | string[];
+  descriptorSchema?: false | JsonSchemaObject;
+  descriptorPaths?: string[];
+  enabled?: boolean;
+  relationDescriptors?: RelationDescriptor[];
+  selected?: string | string[];
+  selectionSeed?: false | NuxtExtensionSelectionSeedOptions;
+};
+
+export type LorionNuxtModuleOptions = {
+  extensionBootstrap?: NuxtExtensionBootstrap;
+  extensions?: NuxtExtensionModuleOptions;
+  logging?:
+    | boolean
+    | {
+        reporter?: NuxtExtensionBootstrapReporter;
+      };
+  providers?: NuxtProviderSelectionModuleOptions;
+  runtimeConfig?: RuntimeConfigNuxtModuleOptions;
+};
+
+declare module 'nuxt/schema' {
+  interface NuxtConfig {
+    lorion?: LorionNuxtModuleOptions;
+  }
+}