@ucdjs/pipelines-loader 0.0.1-beta.6 → 0.0.1-beta.8

package/README.md

@@ -2,7 +2,6 @@
 
 [![npm version][npm-version-src]][npm-version-href]
 [![npm downloads][npm-downloads-src]][npm-downloads-href]
-[![codecov][codecov-src]][codecov-href]
 
 > [!IMPORTANT]
 > This is an internal package. It may change without warning and is not subject to semantic versioning. Use at your own risk.
@@ -23,5 +22,3 @@ Published under [MIT License](./LICENSE).
 [npm-version-href]: https://npmjs.com/package/@ucdjs/pipelines-loader
 [npm-downloads-src]: https://img.shields.io/npm/dm/@ucdjs/pipelines-loader?style=flat&colorA=18181B&colorB=4169E1
 [npm-downloads-href]: https://npmjs.com/package/@ucdjs/pipelines-loader
-[codecov-src]: https://img.shields.io/codecov/c/gh/ucdjs/ucd?style=flat&colorA=18181B&colorB=4169E1
-[codecov-href]: https://codecov.io/gh/ucdjs/ucd

package/dist/discover-C_YruvBu.d.mts

@@ -0,0 +1,69 @@
+//#region src/errors.d.ts
+declare const PIPELINE_LOADER_ISSUE_CODES: readonly ["INVALID_LOCATOR", "CACHE_MISS", "REF_RESOLUTION_FAILED", "DOWNLOAD_FAILED", "MATERIALIZE_FAILED", "DISCOVERY_FAILED", "BUNDLE_RESOLVE_FAILED", "BUNDLE_TRANSFORM_FAILED", "IMPORT_FAILED", "INVALID_EXPORT"];
+type PipelineLoaderIssueCode = (typeof PIPELINE_LOADER_ISSUE_CODES)[number];
+type PipelineLoaderIssueScope = "locator" | "repository" | "discovery" | "file" | "bundle" | "import";
+interface PipelineLoaderIssue {
+  code: PipelineLoaderIssueCode;
+  scope: PipelineLoaderIssueScope;
+  message: string;
+  locator?: unknown;
+  repositoryPath?: string;
+  filePath?: string;
+  relativePath?: string;
+  cause?: Error;
+  meta?: Record<string, unknown>;
+}
+declare class PipelineLoaderError extends Error {
+  readonly code: PipelineLoaderIssueCode;
+  constructor(code: PipelineLoaderIssueCode, message: string, options?: ErrorOptions);
+}
+declare class CacheMissError extends PipelineLoaderError {
+  readonly provider: string;
+  readonly owner: string;
+  readonly repo: string;
+  readonly ref: string;
+  constructor(provider: string, owner: string, repo: string, ref: string);
+}
+declare class BundleError extends PipelineLoaderError {
+  readonly entryPath: string;
+  constructor(entryPath: string, message: string, options?: ErrorOptions);
+}
+declare class BundleResolveError extends PipelineLoaderError {
+  readonly entryPath: string;
+  readonly importPath: string;
+  constructor(entryPath: string, importPath: string, options?: ErrorOptions);
+}
+declare class BundleTransformError extends PipelineLoaderError {
+  readonly entryPath: string;
+  readonly line?: number;
+  readonly column?: number;
+  constructor(entryPath: string, options?: ErrorOptions & {
+    line?: number;
+    column?: number;
+  });
+}
+//#endregion
+//#region src/discover.d.ts
+interface RemoteOriginMeta {
+  provider: "github" | "gitlab";
+  owner: string;
+  repo: string;
+  ref: string;
+  path?: string;
+}
+interface DiscoverPipelineFilesOptions {
+  repositoryPath: string;
+  patterns?: string | string[];
+  origin?: RemoteOriginMeta;
+}
+interface DiscoverPipelineFilesResult {
+  files: Array<{
+    filePath: string;
+    relativePath: string;
+    origin?: RemoteOriginMeta;
+  }>;
+  issues: PipelineLoaderIssue[];
+}
+declare function discoverPipelineFiles(options: DiscoverPipelineFilesOptions): Promise<DiscoverPipelineFilesResult>;
+//#endregion
+export { BundleError as a, CacheMissError as c, discoverPipelineFiles as i, PipelineLoaderError as l, DiscoverPipelineFilesResult as n, BundleResolveError as o, RemoteOriginMeta as r, BundleTransformError as s, DiscoverPipelineFilesOptions as t, PipelineLoaderIssue as u };

package/dist/discover.d.mts

@@ -0,0 +1,2 @@
+import { i as discoverPipelineFiles, n as DiscoverPipelineFilesResult, r as RemoteOriginMeta, t as DiscoverPipelineFilesOptions } from "./discover-C_YruvBu.mjs";
+export { DiscoverPipelineFilesOptions, DiscoverPipelineFilesResult, RemoteOriginMeta, discoverPipelineFiles };

package/dist/discover.mjs

@@ -0,0 +1,53 @@
+import { relative } from "node:path";
+import { glob } from "tinyglobby";
+//#region src/discover.ts
+const TRAILING_SLASH_RE = /\/$/;
+const BACKSLASH_RE = /\\/g;
+function joinOriginPath(origin, relativePath) {
+	if (!origin) return void 0;
+	return {
+		...origin,
+		path: origin.path ? `${origin.path.replace(TRAILING_SLASH_RE, "")}/${relativePath}` : relativePath
+	};
+}
+async function discoverPipelineFiles(options) {
+	const patterns = options.patterns ? Array.isArray(options.patterns) ? options.patterns : [options.patterns] : ["**/*.ucd-pipeline.ts"];
+	try {
+		return {
+			files: (await glob(patterns, {
+				cwd: options.repositoryPath,
+				ignore: [
+					"node_modules/**",
+					"**/node_modules/**",
+					"**/dist/**",
+					"**/build/**",
+					"**/.git/**"
+				],
+				absolute: true,
+				onlyFiles: true
+			})).map((filePath) => {
+				const relativePath = relative(options.repositoryPath, filePath).replace(BACKSLASH_RE, "/");
+				return {
+					filePath,
+					relativePath,
+					origin: joinOriginPath(options.origin, relativePath)
+				};
+			}),
+			issues: []
+		};
+	} catch (err) {
+		const cause = err instanceof Error ? err : new Error(String(err));
+		return {
+			files: [],
+			issues: [{
+				code: "DISCOVERY_FAILED",
+				scope: "discovery",
+				message: cause.message,
+				repositoryPath: options.repositoryPath,
+				cause
+			}]
+		};
+	}
+}
+//#endregion
+export { discoverPipelineFiles };

package/dist/index.d.mts

@@ -1,16 +1,125 @@
-import { a as LocalSource, i as LoadedPipelineFile, n as GitLabSource, o as PipelineLoadError, r as LoadPipelinesResult, s as PipelineSource, t as GitHubSource } from "./types-Br8gGmsN.mjs";
-import { i as loadRemotePipelines, n as LoadRemotePipelinesOptions, r as findRemotePipelineFiles, t as FindRemotePipelineFilesOptions } from "./remote-PQ_FXnt1.mjs";
+import { a as BundleError, c as CacheMissError, l as PipelineLoaderError, o as BundleResolveError, r as RemoteOriginMeta, s as BundleTransformError, u as PipelineLoaderIssue } from "./discover-C_YruvBu.mjs";
+import { PipelineDefinition } from "@ucdjs/pipelines-core";
 
+//#region src/cache.d.ts
+type RemoteProvider = "github" | "gitlab";
+interface RemoteCacheStatus {
+  provider: RemoteProvider;
+  owner: string;
+  repo: string;
+  ref: string;
+  commitSha: string;
+  cacheDir: string;
+  markerPath: string;
+  cached: boolean;
+  syncedAt: string | null;
+}
+declare function getRemoteSourceCacheStatus(input: {
+  provider: RemoteProvider;
+  owner: string;
+  repo: string;
+  ref?: string;
+}): Promise<RemoteCacheStatus>;
+/**
+ * Write a cache marker for a remote source.
+ * Call this after downloading and extracting the archive.
+ */
+declare function writeCacheMarker(input: {
+  provider: RemoteProvider;
+  owner: string;
+  repo: string;
+  ref: string;
+  commitSha: string;
+  cacheDir: string;
+  markerPath: string;
+}): Promise<void>;
+declare function clearRemoteSourceCache(input: {
+  provider: RemoteProvider;
+  owner: string;
+  repo: string;
+  ref?: string;
+}): Promise<boolean>;
+/**
+ * List all cached remote sources.
+ */
+declare function listCachedSources(): Promise<Array<{
+  source: string;
+  owner: string;
+  repo: string;
+  ref: string;
+  commitSha: string;
+  syncedAt: string;
+  cacheDir: string;
+}>>;
+//#endregion
 //#region src/loader.d.ts
+interface LoadedPipelineFile {
+  filePath: string;
+  pipelines: PipelineDefinition[];
+  exportNames: string[];
+}
+interface LoadPipelinesResult {
+  pipelines: PipelineDefinition[];
+  files: LoadedPipelineFile[];
+  issues: PipelineLoaderIssue[];
+}
 declare function loadPipelineFile(filePath: string): Promise<LoadedPipelineFile>;
-interface LoadPipelinesOptions {
-  throwOnError?: boolean;
+declare function loadPipelinesFromPaths(filePaths: string[]): Promise<LoadPipelinesResult>;
+//#endregion
+//#region src/materialize.d.ts
+interface LocalPipelineLocator {
+  kind: "local";
+  path: string;
+}
+interface RemotePipelineLocator {
+  kind: "remote";
+  provider: "github" | "gitlab";
+  owner: string;
+  repo: string;
+  ref?: string;
+  path?: string;
+}
+type PipelineLocator = LocalPipelineLocator | RemotePipelineLocator;
+interface MaterializePipelineLocatorResult {
+  repositoryPath?: string;
+  filePath?: string;
+  relativePath?: string;
+  origin?: RemoteOriginMeta;
+  issues: PipelineLoaderIssue[];
+}
+declare function materializePipelineLocator(locator: PipelineLocator): Promise<MaterializePipelineLocatorResult>;
+//#endregion
+//#region src/locator.d.ts
+declare function parsePipelineLocator(input: string): PipelineLocator;
+declare function parseRemoteSourceUrl(url: string): RemotePipelineLocator | null;
+//#endregion
+//#region src/remote.d.ts
+interface UpdateCheckResult {
+  hasUpdate: boolean;
+  currentSha: string | null;
+  remoteSha: string;
+  error?: Error;
 }
-declare function loadPipelinesFromPaths(filePaths: string[], options?: LoadPipelinesOptions): Promise<LoadPipelinesResult>;
-interface FindPipelineFilesOptions {
-  patterns?: string | string[];
-  cwd?: string;
+declare function checkRemoteLocatorUpdates(input: {
+  provider: "github" | "gitlab";
+  owner: string;
+  repo: string;
+  ref?: string;
+}): Promise<UpdateCheckResult>;
+interface SyncResult {
+  success: boolean;
+  updated: boolean;
+  previousSha: string | null;
+  newSha: string;
+  cacheDir: string;
+  error?: Error;
 }
-declare function findPipelineFiles(options?: FindPipelineFilesOptions): Promise<string[]>;
+declare function ensureRemoteLocator(input: {
+  provider: "github" | "gitlab";
+  owner: string;
+  repo: string;
+  ref?: string;
+  force?: boolean;
+}): Promise<SyncResult>;
 //#endregion
-export { type FindPipelineFilesOptions, type FindRemotePipelineFilesOptions, type GitHubSource, type GitLabSource, type LoadPipelinesOptions, type LoadPipelinesResult, type LoadRemotePipelinesOptions, type LoadedPipelineFile, type LocalSource, type PipelineLoadError, type PipelineSource, findPipelineFiles, findRemotePipelineFiles, loadPipelineFile, loadPipelinesFromPaths, loadRemotePipelines };
+export { BundleError, BundleResolveError, BundleTransformError, CacheMissError, type LoadedPipelineFile, type LocalPipelineLocator, PipelineLoaderError, type PipelineLoaderIssue, type PipelineLocator, type RemoteCacheStatus, type RemoteOriginMeta, type RemotePipelineLocator, type SyncResult, type UpdateCheckResult, checkRemoteLocatorUpdates, clearRemoteSourceCache, ensureRemoteLocator, getRemoteSourceCacheStatus, listCachedSources, loadPipelineFile, loadPipelinesFromPaths, materializePipelineLocator, parsePipelineLocator, parseRemoteSourceUrl, writeCacheMarker };