@milaboratories/pl-model-common 1.13.3 → 1.13.5

package/src/drivers/pframe/data_info.ts

@@ -235,13 +235,19 @@ export interface BinaryPartitionedDataInfoEntries<Blob> {
   parts: PColumnDataEntry<BinaryChunk<Blob>>[];
 }
 
+/**
+ * Union type representing all possible entry-based partitioned data storage formats
+ */
+export type PartitionedDataInfoEntries<Blob> =
+  | JsonPartitionedDataInfoEntries<Blob>
+  | BinaryPartitionedDataInfoEntries<Blob>;
+
 /**
  * Union type representing all possible entry-based data storage formats
  */
 export type DataInfoEntries<Blob> =
   | JsonDataInfoEntries
-  | JsonPartitionedDataInfoEntries<Blob>
-  | BinaryPartitionedDataInfoEntries<Blob>;
+  | PartitionedDataInfoEntries<Blob>;
 
 /**
  * Type guard function that checks if the given value is a valid DataInfoEntries.
@@ -280,6 +286,18 @@ export function isDataInfoEntries<Blob>(value: unknown): value is DataInfoEntrie
   }
 }
 
+/**
+ * Type guard function that checks if the given value is a valid PartitionedDataInfoEntries.
+ *
+ * @template Blob - Type parameter representing the storage reference type
+ * @param value - The value to check
+ * @returns True if the value is a valid PartitionedDataInfoEntries, false otherwise
+ */
+export function isPartitionedDataInfoEntries<Blob>(value: unknown): value is PartitionedDataInfoEntries<Blob> {
+  if (!isDataInfoEntries(value)) return false;
+  return value.type === 'JsonPartitioned' || value.type === 'BinaryPartitioned';
+}
+
 /**
  * Converts DataInfo to DataInfoEntries
  *

package/src/drivers/pframe/spec/anchored.ts

@@ -1,11 +1,11 @@
 import canonicalize from 'canonicalize';
-import type { AxisId, PColumnSpec } from './spec';
-import { getAxisId, matchAxisId } from './spec';
-import type { AAxisSelector, AnchorAxisRef, AnchorAxisRefByIdx, AnchoredPColumnId, AnchoredPColumnSelector, AxisSelector, PColumnSelector } from './selectors';
-import type { AxisFilter } from './filtered_column';
 import type { PValue } from '../data_types';
+import type { AxisFilter } from './filtered_column';
 import type { SUniversalPColumnId, UniversalPColumnId } from './ids';
 import { stringifyColumnId } from './ids';
+import type { AAxisSelector, AnchorAxisRef, AnchorAxisRefByIdx, AnchoredPColumnId, AnchoredPColumnSelector, AxisSelector, PColumnSelector } from './selectors';
+import type { AxisId, PColumnSpec } from './spec';
+import { getAxisId, matchAxisId } from './spec';
 
 //
 // Helper functions
@@ -40,7 +40,7 @@ export class AnchoredIdDeriver {
    * Creates a new anchor context from a set of anchor column specifications
    * @param anchors Record of anchor column specifications indexed by anchor ID
    */
-  constructor(private readonly anchors: Record<string, PColumnSpec>) {
+  constructor(public readonly anchors: Record<string, PColumnSpec>) {
     const anchorEntries = Object.entries(anchors);
     anchorEntries.sort((a, b) => a[0].localeCompare(b[0]));
     for (const [anchorId, spec] of anchorEntries) {
@@ -121,7 +121,8 @@ export class AnchoredIdDeriver {
     result.axes = spec.axesSpec.map((axis) => {
       const key = axisKey(axis);
       const anchorAxisRef = this.axes.get(key);
-      return anchorAxisRef ?? axis;
+      if (anchorAxisRef === undefined) return getAxisId(axis);
+      else return anchorAxisRef;
     });
 
     // If no axis filters are provided, return the anchored ID as is
@@ -171,16 +172,29 @@ export class AnchoredIdDeriver {
   }
 }
 
+/**
+ * Options for the resolveAnchors function
+ */
+export type ResolveAnchorsOptions = {
+  /**
+   * If true, missing domain keys in anchors will be ignored.
+   * If false (default), an error will be thrown.
+   */
+  ignoreMissingDomains?: boolean;
+};
+
 /**
  * Resolves anchored references in a column matcher to create a non-anchored matcher.
  * Doing an opposite operation to {@link AnchorIdDeriver.derive()}.
  *
  * @param anchors - Record of anchor column specifications indexed by anchor id
  * @param matcher - An anchored column matcher (or id, which is subtype of it) containing references that need to be resolved
+ * @param options - Options for resolving anchors
  * @returns A non-anchored column matcher with all references resolved to actual values
  */
-export function resolveAnchors(anchors: Record<string, PColumnSpec>, matcher: AnchoredPColumnSelector): PColumnSelector {
+export function resolveAnchors(anchors: Record<string, PColumnSpec>, matcher: AnchoredPColumnSelector, options?: ResolveAnchorsOptions): PColumnSelector {
   const result = { ...matcher };
+  const ignoreMissingDomains = options?.ignoreMissingDomains ?? false;
 
   if (result.domainAnchor !== undefined) {
     const anchorSpec = anchors[result.domainAnchor];
@@ -203,8 +217,11 @@ export function resolveAnchors(anchors: Record<string, PColumnSpec>, matcher: An
         if (!anchorSpec)
           throw new Error(`Anchor "${value.anchor}" not found for domain key "${key}"`);
 
-        if (!anchorSpec.domain || anchorSpec.domain[key] === undefined)
-          throw new Error(`Domain key "${key}" not found in anchor "${value.anchor}"`);
+        if (!anchorSpec.domain || anchorSpec.domain[key] === undefined) {
+          if (!ignoreMissingDomains)
+            throw new Error(`Domain key "${key}" not found in anchor "${value.anchor}"`);
+          continue;
+        }
 
         resolvedDomain[key] = anchorSpec.domain[key];
       }

package/src/drivers/pframe/spec/ids.ts

@@ -2,6 +2,7 @@ import type { Branded } from '../../../branding';
 import type { AnchoredPColumnId } from './selectors';
 import type { FilteredPColumnId } from './filtered_column';
 import canonicalize from 'canonicalize';
+import type { PObjectId } from '../../../pool';
 /**
  * Universal column identifier optionally anchored and optionally filtered.
  */
@@ -10,7 +11,7 @@ export type UniversalPColumnId = AnchoredPColumnId | FilteredPColumnId;
 /**
  * Canonically serialized {@link UniversalPColumnId}.
  */
-export type SUniversalPColumnId = Branded<string, 'SUniversalPColumnId'>;
+export type SUniversalPColumnId = Branded<PObjectId, 'SUniversalPColumnId', '__pl_model_brand_2__'>;
 
 /**
  * Canonically serializes a {@link UniversalPColumnId} to a string.