@murumets-ee/imports 0.49.0 → 0.51.0

package/dist/{parts-schema-x8_GRYWc.d.mts → parts-schema-u5kr5zFg.d.mts}

@@ -1,4 +1,4 @@
-import { r as RowResult } from "./transform-CABBaYmF.mjs";
+import { i as RowTransform, r as RowResult } from "./transform-WeiiLdYP.mjs";
 import { z } from "zod";
 import { PartsDocument } from "@murumets-ee/search-elasticsearch";
 
@@ -250,6 +250,362 @@ declare function rowError(errorType: string, message: string, field: string): {
   };
 };
 //#endregion
+//#region src/mapping/engine.d.ts
+/** One column-map entry. `target` is checked against the schema whitelist separately. */
+declare const mappingColumnSchema: z.ZodObject<{
+  /** Source header name (or positional index string for headerless feeds). */source: z.ZodString; /** Target field key — must be in the chosen schema's whitelist (enforced in `buildMappingTransform`). */
+  target: z.ZodString; /** Ordered per-column cleaning ops. Defaults to none. */
+  transforms: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<"op", [z.ZodObject<{
+    op: z.ZodLiteral<"trim">;
+  }, "strip", z.ZodTypeAny, {
+    op: "trim";
+  }, {
+    op: "trim";
+  }>, z.ZodObject<{
+    op: z.ZodLiteral<"uppercase">;
+  }, "strip", z.ZodTypeAny, {
+    op: "uppercase";
+  }, {
+    op: "uppercase";
+  }>, z.ZodObject<{
+    op: z.ZodLiteral<"lowercase">;
+  }, "strip", z.ZodTypeAny, {
+    op: "lowercase";
+  }, {
+    op: "lowercase";
+  }>, z.ZodObject<{
+    op: z.ZodLiteral<"stripPrefix">;
+    value: z.ZodString;
+  }, "strip", z.ZodTypeAny, {
+    value: string;
+    op: "stripPrefix";
+  }, {
+    value: string;
+    op: "stripPrefix";
+  }>, z.ZodObject<{
+    op: z.ZodLiteral<"stripSuffix">;
+    value: z.ZodString;
+  }, "strip", z.ZodTypeAny, {
+    value: string;
+    op: "stripSuffix";
+  }, {
+    value: string;
+    op: "stripSuffix";
+  }>, z.ZodObject<{
+    op: z.ZodLiteral<"defaultIfEmpty">;
+    value: z.ZodString;
+  }, "strip", z.ZodTypeAny, {
+    value: string;
+    op: "defaultIfEmpty";
+  }, {
+    value: string;
+    op: "defaultIfEmpty";
+  }>, z.ZodObject<{
+    op: z.ZodLiteral<"number">;
+  }, "strip", z.ZodTypeAny, {
+    op: "number";
+  }, {
+    op: "number";
+  }>, z.ZodObject<{
+    op: z.ZodLiteral<"europeanNumber">;
+  }, "strip", z.ZodTypeAny, {
+    op: "europeanNumber";
+  }, {
+    op: "europeanNumber";
+  }>]>, "many">>;
+}, "strip", z.ZodTypeAny, {
+  source: string;
+  target: string;
+  transforms: ({
+    op: "trim";
+  } | {
+    op: "uppercase";
+  } | {
+    op: "lowercase";
+  } | {
+    value: string;
+    op: "stripPrefix";
+  } | {
+    value: string;
+    op: "stripSuffix";
+  } | {
+    value: string;
+    op: "defaultIfEmpty";
+  } | {
+    op: "number";
+  } | {
+    op: "europeanNumber";
+  })[];
+}, {
+  source: string;
+  target: string;
+  transforms?: ({
+    op: "trim";
+  } | {
+    op: "uppercase";
+  } | {
+    op: "lowercase";
+  } | {
+    value: string;
+    op: "stripPrefix";
+  } | {
+    value: string;
+    op: "stripSuffix";
+  } | {
+    value: string;
+    op: "defaultIfEmpty";
+  } | {
+    op: "number";
+  } | {
+    op: "europeanNumber";
+  })[] | undefined;
+}>;
+type MappingColumn = z.infer<typeof mappingColumnSchema>;
+/**
+ * Decimal + thousands separators for the `number` transform.
+ *
+ * The two MUST differ: `parseNumber` strips every thousands separator FIRST, so a
+ * config where `decimal === thousands` (e.g. both `,`) would strip the decimal
+ * separator too — `326,88` → `32688`, a silent 100× error rather than a row error.
+ * Rejected at save (`assertValidMapping`) AND at run (`mappingConfigSchema`).
+ */
+declare const numberFormatSchema: z.ZodEffects<z.ZodObject<{
+  decimal: z.ZodEnum<[".", ","]>;
+  thousands: z.ZodEnum<["", ".", ",", " "]>;
+}, "strip", z.ZodTypeAny, {
+  decimal: "." | ",";
+  thousands: "" | "." | "," | " ";
+}, {
+  decimal: "." | ",";
+  thousands: "" | "." | "," | " ";
+}>, {
+  decimal: "." | ",";
+  thousands: "" | "." | "," | " ";
+}, {
+  decimal: "." | ",";
+  thousands: "" | "." | "," | " ";
+}>;
+/**
+ * The portable mapping config — the subset of an `import_mapping` row the engine
+ * needs. The enqueuer SNAPSHOTS this into `import_run.params.mapping` so a run
+ * records the exact mapping it used (reproducible) and the transform stays a pure
+ * function of `(row, ctx)` with no per-row DB I/O.
+ */
+declare const mappingConfigSchema: z.ZodObject<{
+  targetSchema: z.ZodString;
+  numberFormat: z.ZodEffects<z.ZodObject<{
+    decimal: z.ZodEnum<[".", ","]>;
+    thousands: z.ZodEnum<["", ".", ",", " "]>;
+  }, "strip", z.ZodTypeAny, {
+    decimal: "." | ",";
+    thousands: "" | "." | "," | " ";
+  }, {
+    decimal: "." | ",";
+    thousands: "" | "." | "," | " ";
+  }>, {
+    decimal: "." | ",";
+    thousands: "" | "." | "," | " ";
+  }, {
+    decimal: "." | ",";
+    thousands: "" | "." | "," | " ";
+  }>;
+  columnMap: z.ZodArray<z.ZodObject<{
+    /** Source header name (or positional index string for headerless feeds). */source: z.ZodString; /** Target field key — must be in the chosen schema's whitelist (enforced in `buildMappingTransform`). */
+    target: z.ZodString; /** Ordered per-column cleaning ops. Defaults to none. */
+    transforms: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<"op", [z.ZodObject<{
+      op: z.ZodLiteral<"trim">;
+    }, "strip", z.ZodTypeAny, {
+      op: "trim";
+    }, {
+      op: "trim";
+    }>, z.ZodObject<{
+      op: z.ZodLiteral<"uppercase">;
+    }, "strip", z.ZodTypeAny, {
+      op: "uppercase";
+    }, {
+      op: "uppercase";
+    }>, z.ZodObject<{
+      op: z.ZodLiteral<"lowercase">;
+    }, "strip", z.ZodTypeAny, {
+      op: "lowercase";
+    }, {
+      op: "lowercase";
+    }>, z.ZodObject<{
+      op: z.ZodLiteral<"stripPrefix">;
+      value: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+      value: string;
+      op: "stripPrefix";
+    }, {
+      value: string;
+      op: "stripPrefix";
+    }>, z.ZodObject<{
+      op: z.ZodLiteral<"stripSuffix">;
+      value: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+      value: string;
+      op: "stripSuffix";
+    }, {
+      value: string;
+      op: "stripSuffix";
+    }>, z.ZodObject<{
+      op: z.ZodLiteral<"defaultIfEmpty">;
+      value: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+      value: string;
+      op: "defaultIfEmpty";
+    }, {
+      value: string;
+      op: "defaultIfEmpty";
+    }>, z.ZodObject<{
+      op: z.ZodLiteral<"number">;
+    }, "strip", z.ZodTypeAny, {
+      op: "number";
+    }, {
+      op: "number";
+    }>, z.ZodObject<{
+      op: z.ZodLiteral<"europeanNumber">;
+    }, "strip", z.ZodTypeAny, {
+      op: "europeanNumber";
+    }, {
+      op: "europeanNumber";
+    }>]>, "many">>;
+  }, "strip", z.ZodTypeAny, {
+    source: string;
+    target: string;
+    transforms: ({
+      op: "trim";
+    } | {
+      op: "uppercase";
+    } | {
+      op: "lowercase";
+    } | {
+      value: string;
+      op: "stripPrefix";
+    } | {
+      value: string;
+      op: "stripSuffix";
+    } | {
+      value: string;
+      op: "defaultIfEmpty";
+    } | {
+      op: "number";
+    } | {
+      op: "europeanNumber";
+    })[];
+  }, {
+    source: string;
+    target: string;
+    transforms?: ({
+      op: "trim";
+    } | {
+      op: "uppercase";
+    } | {
+      op: "lowercase";
+    } | {
+      value: string;
+      op: "stripPrefix";
+    } | {
+      value: string;
+      op: "stripSuffix";
+    } | {
+      value: string;
+      op: "defaultIfEmpty";
+    } | {
+      op: "number";
+    } | {
+      op: "europeanNumber";
+    })[] | undefined;
+  }>, "many">;
+}, "strip", z.ZodTypeAny, {
+  targetSchema: string;
+  numberFormat: {
+    decimal: "." | ",";
+    thousands: "" | "." | "," | " ";
+  };
+  columnMap: {
+    source: string;
+    target: string;
+    transforms: ({
+      op: "trim";
+    } | {
+      op: "uppercase";
+    } | {
+      op: "lowercase";
+    } | {
+      value: string;
+      op: "stripPrefix";
+    } | {
+      value: string;
+      op: "stripSuffix";
+    } | {
+      value: string;
+      op: "defaultIfEmpty";
+    } | {
+      op: "number";
+    } | {
+      op: "europeanNumber";
+    })[];
+  }[];
+}, {
+  targetSchema: string;
+  numberFormat: {
+    decimal: "." | ",";
+    thousands: "" | "." | "," | " ";
+  };
+  columnMap: {
+    source: string;
+    target: string;
+    transforms?: ({
+      op: "trim";
+    } | {
+      op: "uppercase";
+    } | {
+      op: "lowercase";
+    } | {
+      value: string;
+      op: "stripPrefix";
+    } | {
+      value: string;
+      op: "stripSuffix";
+    } | {
+      value: string;
+      op: "defaultIfEmpty";
+    } | {
+      op: "number";
+    } | {
+      op: "europeanNumber";
+    })[] | undefined;
+  }[];
+}>;
+type MappingConfig = z.infer<typeof mappingConfigSchema>;
+/**
+ * Build a `RowTransform` from a validated mapping config + its target schema.
+ *
+ * Throws at BUILD time if any `column_map` target is outside the schema's
+ * whitelist (deny-by-default, R02) — so a misconfigured mapping fails loudly
+ * before a single row is written, rather than silently dropping a column.
+ *
+ * Generic over the schema's output type, so passing the concrete `partsSchema`
+ * yields a `RowTransform<PartsDocument>` (the carmaker path keeps its typing); the
+ * registry-resolved `TargetSchema<unknown>` yields `RowTransform<unknown>` (the
+ * `commerce:mapping` path, where the output type isn't known until runtime).
+ */
+declare function buildMappingTransform<TOut>(config: MappingConfig, schema: TargetSchema<TOut>): RowTransform<TOut>;
+/** The minimal shape `resolveMapping` needs — satisfied by an `import_mapping` row or a test fixture. */
+interface ResolvableMapping {
+  /** `null` = supplier default (applies to all brands). */
+  brandId: string | null;
+  active: boolean;
+}
+/**
+ * Most-specific resolution (D002 ladder): given the candidate mappings for one
+ * `(supplier, target_schema)` and the requested brand, return the brand-specific
+ * mapping if one exists, else the supplier-default (`brandId === null`). Inactive
+ * mappings are skipped. Returns `undefined` when nothing matches.
+ */
+declare function resolveMapping<M extends ResolvableMapping>(mappings: readonly M[], brandId: string | null): M | undefined;
+//#endregion
 //#region src/mapping/parts-schema.d.ts
 /**
  * Params the `parts` schema reads from the run — the per-(supplier, brand)
@@ -305,5 +661,5 @@ declare function normalizeCode(s: string): string;
  */
 declare const partsSchema: TargetSchema<PartsDocument>;
 //#endregion
-export { toMinorUnits as C, parseNumber as S, ColumnTransformOpDescriptor as _, BuildRowContext as a, NumberFormat as b, TargetField as c, rowError as d, textOrNull as f, ColumnTransformOp as g, ColumnTransform as h, partsSchema as i, TargetSchema as l, CellValue as m, normalizeCode as n, MappedRow as o, COLUMN_TRANSFORM_OPS as p, partsParamsSchema as r, NumberOutcome as s, PartsParams as t, numberCell as u, applyColumnTransforms as v, parseEuropeanNumber as x, columnTransformSchema as y };
-//# sourceMappingURL=parts-schema-x8_GRYWc.d.mts.map
+export { parseNumber as A, ColumnTransform as C, columnTransformSchema as D, applyColumnTransforms as E, NumberFormat as O, CellValue as S, ColumnTransformOpDescriptor as T, TargetSchema as _, MappingColumn as a, textOrNull as b, buildMappingTransform as c, numberFormatSchema as d, resolveMapping as f, TargetField as g, NumberOutcome as h, partsSchema as i, toMinorUnits as j, parseEuropeanNumber as k, mappingColumnSchema as l, MappedRow as m, normalizeCode as n, MappingConfig as o, BuildRowContext as p, partsParamsSchema as r, ResolvableMapping as s, PartsParams as t, mappingConfigSchema as u, numberCell as v, ColumnTransformOp as w, COLUMN_TRANSFORM_OPS as x, rowError as y };
+//# sourceMappingURL=parts-schema-u5kr5zFg.d.mts.map

package/dist/parts-schema-u5kr5zFg.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parts-schema-u5kr5zFg.d.mts","names":[],"sources":["../src/mapping/number-format.ts","../src/mapping/column-transforms.ts","../src/mapping/target-schema.ts","../src/mapping/engine.ts","../src/mapping/parts-schema.ts"],"mappings":"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"}

package/dist/plugin.d.mts

@@ -1,4 +1,4 @@
-import { n as EsClientResolver, r as FilePathResolver, s as PairSink, t as EnsureIndexResolver } from "./worker-DRTgbtT7.mjs";
+import { n as EsClientResolver, r as FilePathResolver, s as PairSink, t as EnsureIndexResolver } from "./worker-DH3SN-91.mjs";
 import { ImportsStorageFactory } from "./storage.mjs";
 import { IndexConfig } from "@murumets-ee/search-elasticsearch";
 

package/dist/plugin.mjs

@@ -1,2 +1,2 @@
-import{n as e,o as t,u as n}from"./transform-DIzWppgJ.mjs";import{registerImportsStorageFactory as r}from"./storage.mjs";import{n as i,t as a}from"./mapping-transform-D76b-P-p.mjs";import{r as o,t as s}from"./carmaker-feed-CxhZBrkO.mjs";import{createImportsRunDeadListener as c,createRunImportHandler as l,importsRunJob as u}from"./worker.mjs";import{definePlugin as d}from"@murumets-ee/core";import{z as f}from"zod";import{inArray as p}from"drizzle-orm";import{createIndex as m,dropIndex as h,readAliasTargets as g,reindex as _}from"@murumets-ee/search-elasticsearch";import{defineJob as v}from"@murumets-ee/queue/client";const y=f.object({toIndex:f.string().min(1).optional(),allowExisting:f.boolean().optional(),dropOld:f.boolean().optional(),batchSize:f.number().int().min(1).max(1e4).optional()}),b=v({name:`imports:reindex`,description:`Copy the aliased parts index into a new physical index built with the current mapping, then atomically swap the alias onto it.`,schema:y,defaultRetries:0}),x=[`pending`,`running`];async function S(e){let t=e.getTable();return e.count({where:p(t.status,[...x])})}function C(e){let t=/^(.*)_v(\d+)$/.exec(e);if(!t)return null;let[,n,r]=t;if(n===void 0||r===void 0)return null;let i=Number.parseInt(r,10)+1;return Number.isSafeInteger(i)?`${n}_v${i}`:null}function w(e){let{esClient:t,esIndex:n,indexConfig:r,importRuns:i,logger:a}=e;return async e=>{let o=a?.child({jobId:e.id,type:`imports:reindex`});if(r===void 0)throw Error(`imports:reindex requires imports({ indexConfig }) — the destination index must be created with the settings + mappings this app intends, otherwise Elasticsearch auto-creates it with inferred text mappings and the reindex silently discards the mapping change it exists to ship. Pass your app's index config (for the parts catalog: partsIndexConfig from @murumets-ee/search-elasticsearch).`);let s=y.parse(e.payload);if(i!==void 0){let e=await S(i);if(e>0)throw Error(`imports:reindex: ${e} feed import(s) are pending or running. An import writes through the alias "${n}", which points at the SOURCE index for the whole copy, so anything it writes now would be lost at the swap. Wait for them to finish (or cancel them) and re-run.`)}let c=await t(),l=Object.keys(await g(c,n)).sort();if(l.length>1)throw Error(`imports:reindex: alias "${n}" points at ${l.length} indices (${l.join(`, `)}). Reindexing would copy only one of them and then swap, leaving the alias on a mix of stale and fresh data. Resolve the alias to a single index first, then re-run. An interrupted reindex cannot cause this — swapAlias sends its remove with must_exist, so a stale swap fails instead of adding a second target. Look for a manual alias edit, another tool writing to this cluster, or a swap issued before that guard existed.`);let u=l[0];if(u===void 0)throw Error(`imports:reindex: alias "${n}" does not exist, so there is nothing to reindex. Run an import first — imports({ ensureIndex }) bootstraps the alias on the import path.`);let d=s.toIndex??C(u);if(d===null)throw Error(`imports:reindex: alias "${n}" points at "${u}", which does not follow the "<name>_v<N>" convention, so the next version cannot be derived. Pass an explicit destination (\`lumi imports:reindex --to <index>\`).`);let f=d;if(f===u)throw Error(`imports:reindex: destination "${f}" is the index the alias already points at. Reindexing an index onto itself would copy every document over itself and swap the alias onto where it already is. Pass a different --to.`);let p=await c.indices.exists({index:f});if(p&&s.allowExisting!==!0)throw Error(`imports:reindex: destination "${f}" already exists. If it is debris from a failed run, re-run with --resume to continue into it (bulkUpsert is idempotent by _id, so already-copied documents are simply overwritten); if it was created by hand with a different mapping, delete it or pass --to <another-index> instead. Refusing to reuse it silently, because doing so would apply ITS mapping rather than the one you changed.`);e.updateProgress({phase:p?`resuming`:`creating`,fromIndex:u,toIndex:f,processed:0,total:0}),p?o?.warn({fromIndex:u,toIndex:f},`imports:reindex: resuming into an existing destination index (--resume); its EXISTING mapping applies, not indexConfig`):(o?.info({fromIndex:u,toIndex:f},`imports:reindex: creating destination index`),await m(c,{name:f,config:r})),o?.info({fromIndex:u,toIndex:f},`imports:reindex: copying documents`);let v=await _({client:c,alias:n,fromIndex:u,toIndex:f,refreshOnCompletion:!0,...s.batchSize!==void 0&&{batchSize:s.batchSize},...i!==void 0&&{beforeSwap:async()=>{let e=await S(i);if(e>0)throw Error(`imports:reindex: ${e} feed import(s) started while the copy was running. Their documents went to the source index through the alias and are NOT in "${f}", so swapping now would drop them. The alias is untouched and "${f}" is left in place — wait for the import(s), then re-run with --resume to finish.`)}},reportProgress:async({processed:t,total:n})=>{e.updateProgress({phase:`copying`,fromIndex:u,toIndex:f,processed:t,total:n})}});e.updateProgress({phase:`swapped`,fromIndex:u,toIndex:f,processed:v.processed,total:v.processed+v.skipped,skipped:v.skipped}),o?.info({fromIndex:u,toIndex:f,processed:v.processed,skipped:v.skipped},`imports:reindex: alias swapped onto destination`),s.dropOld===!0&&(await h(c,u),o?.info({fromIndex:u},`imports:reindex: dropped source index (--drop-old)`))}}const T=Symbol.for(`@murumets-ee/imports:dead-listener-unsubscribe`);function E(f){let p=f.esIndex,m=f.storageBucket===null?null:{bucket:f.storageBucket??`lumi-imports`,orphanTtlHours:f.orphanUploadTtlHours??2,processedRetentionDays:f.processedRetentionDays??7};return f.storage&&r(f.storage),d({name:`@murumets-ee/imports`,server:{entities:[n,t],init:async t=>{let r=e();if(r.has(`commerce:mapping`)||r.register(a,i),r.has(`commerce:carmaker-feed`)||r.register(s,o),!t.plugins.all().some(e=>e.name===`@murumets-ee/queue`)){t.logger.warn(`imports: queue() plugin not in plugins array — imports:run jobs will not be processed`);return}let d=await import(`@murumets-ee/queue/client`),h=t.getClient(n);d.registerJob(u,l({importRuns:h,transforms:r,esClient:f.esClient,esIndex:p,...f.ensureIndex!==void 0&&{ensureIndex:f.ensureIndex},...f.resolveFilePath!==void 0&&{resolveFilePath:f.resolveFilePath},...f.pairSink!==void 0&&{pairSink:f.pairSink},logger:t.logger.child({pkg:`imports`})})),d.registerJob(b,w({esClient:f.esClient,esIndex:p,importRuns:h,...f.indexConfig!==void 0&&{indexConfig:f.indexConfig},logger:t.logger.child({pkg:`imports`})}));let g=globalThis[T];g&&g();let _=d.addQueueTerminalListener(c({importRuns:h,logger:t.logger.child({pkg:`imports`})}));if(globalThis[T]=_,m!==null){let{cleanupOrphanedImports:e,cleanupProcessedImports:n}=await import(`./cleanup-CHjDgvKT.mjs`).then(e=>e.r),{runAsCli:r}=await import(`@murumets-ee/core`),i=t.logger.child({pkg:`imports`,job:`cleanup`});d.registerJob(d.defineJob({name:`imports:cleanup-orphaned-uploads`,description:`Delete toolkit_files rows in the imports bucket with no matching import_run reference and createdAt older than the configured TTL.`,schedule:`@every 1h`}),async()=>{await r(()=>e({app:t,bucket:m.bucket,ttlHours:m.orphanTtlHours,logger:i}))}),d.registerJob(d.defineJob({name:`imports:cleanup-processed-uploads`,description:`Delete toolkit_files rows for import_runs in terminal status (succeeded/failed/cancelled) whose finishedAt is older than the configured retention window. The import_run row itself is preserved.`,schedule:`@every 1h`}),async()=>{await r(()=>n({app:t,bucket:m.bucket,retentionDays:m.processedRetentionDays,logger:i}))})}t.logger.info({esIndex:p,cleanup:m===null?{enabled:!1}:{enabled:!0,...m}},`Imports plugin initialized`)}}})}export{E as imports};
+import{n as e,o as t,u as n}from"./transform-DwAQ4b-j.mjs";import{registerImportsStorageFactory as r}from"./storage.mjs";import{i,t as a}from"./carmaker-feed-C_MnDaOC.mjs";import{n as o,t as s}from"./mapping-transform-AMFEg1rS.mjs";import{createImportsRunDeadListener as c,createRunImportHandler as l,importsRunJob as u}from"./worker.mjs";import{definePlugin as d}from"@murumets-ee/core";import{z as f}from"zod";import{inArray as p}from"drizzle-orm";import{createIndex as m,dropIndex as h,readAliasTargets as g,reindex as _}from"@murumets-ee/search-elasticsearch";import{defineJob as v}from"@murumets-ee/queue/client";const y=f.object({toIndex:f.string().min(1).optional(),allowExisting:f.boolean().optional(),dropOld:f.boolean().optional(),batchSize:f.number().int().min(1).max(1e4).optional()}),b=v({name:`imports:reindex`,description:`Copy the aliased parts index into a new physical index built with the current mapping, then atomically swap the alias onto it.`,schema:y,defaultRetries:0}),x=[`pending`,`running`];async function S(e){let t=e.getTable();return e.count({where:p(t.status,[...x])})}function C(e){let t=/^(.*)_v(\d+)$/.exec(e);if(!t)return null;let[,n,r]=t;if(n===void 0||r===void 0)return null;let i=Number.parseInt(r,10)+1;return Number.isSafeInteger(i)?`${n}_v${i}`:null}function w(e){let{esClient:t,esIndex:n,indexConfig:r,importRuns:i,logger:a}=e;return async e=>{let o=a?.child({jobId:e.id,type:`imports:reindex`});if(r===void 0)throw Error(`imports:reindex requires imports({ indexConfig }) — the destination index must be created with the settings + mappings this app intends, otherwise Elasticsearch auto-creates it with inferred text mappings and the reindex silently discards the mapping change it exists to ship. Pass your app's index config (for the parts catalog: partsIndexConfig from @murumets-ee/search-elasticsearch).`);let s=y.parse(e.payload);if(i!==void 0){let e=await S(i);if(e>0)throw Error(`imports:reindex: ${e} feed import(s) are pending or running. An import writes through the alias "${n}", which points at the SOURCE index for the whole copy, so anything it writes now would be lost at the swap. Wait for them to finish (or cancel them) and re-run.`)}let c=await t(),l=Object.keys(await g(c,n)).sort();if(l.length>1)throw Error(`imports:reindex: alias "${n}" points at ${l.length} indices (${l.join(`, `)}). Reindexing would copy only one of them and then swap, leaving the alias on a mix of stale and fresh data. Resolve the alias to a single index first, then re-run. An interrupted reindex cannot cause this — swapAlias sends its remove with must_exist, so a stale swap fails instead of adding a second target. Look for a manual alias edit, another tool writing to this cluster, or a swap issued before that guard existed.`);let u=l[0];if(u===void 0)throw Error(`imports:reindex: alias "${n}" does not exist, so there is nothing to reindex. Run an import first — imports({ ensureIndex }) bootstraps the alias on the import path.`);let d=s.toIndex??C(u);if(d===null)throw Error(`imports:reindex: alias "${n}" points at "${u}", which does not follow the "<name>_v<N>" convention, so the next version cannot be derived. Pass an explicit destination (\`lumi imports:reindex --to <index>\`).`);let f=d;if(f===u)throw Error(`imports:reindex: destination "${f}" is the index the alias already points at. Reindexing an index onto itself would copy every document over itself and swap the alias onto where it already is. Pass a different --to.`);let p=await c.indices.exists({index:f});if(p&&s.allowExisting!==!0)throw Error(`imports:reindex: destination "${f}" already exists. If it is debris from a failed run, re-run with --resume to continue into it (bulkUpsert is idempotent by _id, so already-copied documents are simply overwritten); if it was created by hand with a different mapping, delete it or pass --to <another-index> instead. Refusing to reuse it silently, because doing so would apply ITS mapping rather than the one you changed.`);e.updateProgress({phase:p?`resuming`:`creating`,fromIndex:u,toIndex:f,processed:0,total:0}),p?o?.warn({fromIndex:u,toIndex:f},`imports:reindex: resuming into an existing destination index (--resume); its EXISTING mapping applies, not indexConfig`):(o?.info({fromIndex:u,toIndex:f},`imports:reindex: creating destination index`),await m(c,{name:f,config:r})),o?.info({fromIndex:u,toIndex:f},`imports:reindex: copying documents`);let v=await _({client:c,alias:n,fromIndex:u,toIndex:f,refreshOnCompletion:!0,...s.batchSize!==void 0&&{batchSize:s.batchSize},...i!==void 0&&{beforeSwap:async()=>{let e=await S(i);if(e>0)throw Error(`imports:reindex: ${e} feed import(s) started while the copy was running. Their documents went to the source index through the alias and are NOT in "${f}", so swapping now would drop them. The alias is untouched and "${f}" is left in place — wait for the import(s), then re-run with --resume to finish.`)}},reportProgress:async({processed:t,total:n})=>{e.updateProgress({phase:`copying`,fromIndex:u,toIndex:f,processed:t,total:n})}});e.updateProgress({phase:`swapped`,fromIndex:u,toIndex:f,processed:v.processed,total:v.processed+v.skipped,skipped:v.skipped}),o?.info({fromIndex:u,toIndex:f,processed:v.processed,skipped:v.skipped},`imports:reindex: alias swapped onto destination`),s.dropOld===!0&&(await h(c,u),o?.info({fromIndex:u},`imports:reindex: dropped source index (--drop-old)`))}}const T=Symbol.for(`@murumets-ee/imports:dead-listener-unsubscribe`);function E(f){let p=f.esIndex,m=f.storageBucket===null?null:{bucket:f.storageBucket??`lumi-imports`,orphanTtlHours:f.orphanUploadTtlHours??2,processedRetentionDays:f.processedRetentionDays??7};return f.storage&&r(f.storage),d({name:`@murumets-ee/imports`,server:{entities:[n,t],init:async t=>{let r=e();if(r.has(`commerce:mapping`)||r.register(s,o),r.has(`commerce:carmaker-feed`)||r.register(a,i),!t.plugins.all().some(e=>e.name===`@murumets-ee/queue`)){t.logger.warn(`imports: queue() plugin not in plugins array — imports:run jobs will not be processed`);return}let d=await import(`@murumets-ee/queue/client`),h=t.getClient(n);d.registerJob(u,l({importRuns:h,transforms:r,esClient:f.esClient,esIndex:p,...f.ensureIndex!==void 0&&{ensureIndex:f.ensureIndex},...f.resolveFilePath!==void 0&&{resolveFilePath:f.resolveFilePath},...f.pairSink!==void 0&&{pairSink:f.pairSink},logger:t.logger.child({pkg:`imports`})})),d.registerJob(b,w({esClient:f.esClient,esIndex:p,importRuns:h,...f.indexConfig!==void 0&&{indexConfig:f.indexConfig},logger:t.logger.child({pkg:`imports`})}));let g=globalThis[T];g&&g();let _=d.addQueueTerminalListener(c({importRuns:h,logger:t.logger.child({pkg:`imports`})}));if(globalThis[T]=_,m!==null){let{cleanupOrphanedImports:e,cleanupProcessedImports:n}=await import(`./cleanup-DdILFoAP.mjs`).then(e=>e.r),{runAsCli:r}=await import(`@murumets-ee/core`),i=t.logger.child({pkg:`imports`,job:`cleanup`});d.registerJob(d.defineJob({name:`imports:cleanup-orphaned-uploads`,description:`Delete toolkit_files rows in the imports bucket with no matching import_run reference and createdAt older than the configured TTL.`,schedule:`@every 1h`}),async()=>{await r(()=>e({app:t,bucket:m.bucket,ttlHours:m.orphanTtlHours,logger:i}))}),d.registerJob(d.defineJob({name:`imports:cleanup-processed-uploads`,description:`Delete toolkit_files rows for import_runs in terminal status (succeeded/failed/cancelled) whose finishedAt is older than the configured retention window. The import_run row itself is preserved.`,schedule:`@every 1h`}),async()=>{await r(()=>n({app:t,bucket:m.bucket,retentionDays:m.processedRetentionDays,logger:i}))})}t.logger.info({esIndex:p,cleanup:m===null?{enabled:!1}:{enabled:!0,...m}},`Imports plugin initialized`)}}})}export{E as imports};
 //# sourceMappingURL=plugin.mjs.map