data-finder-ts 0.1.3 → 0.1.5

package/README.md

@@ -1,69 +1,42 @@
 # data-finder-ts
 
-TypeScript port of [data-finder](https://github.com/jackie-h/data-finder), a model-driven SQL query builder with temporal (milestoned) data support. A Python generator reads the same mapping definitions used by the Python project and emits strongly-typed TypeScript finder classes.
+TypeScript port of [data-finder](https://github.com/jackie-h/data-finder), a model-driven SQL query builder with temporal (milestoned) data support. A Python generator reads mapping definitions and emits strongly-typed TypeScript finder classes.
 
-## What it does
+For runtime usage and query API see **[FINDERS.md](FINDERS.md)**.
 
-You define a mapping between your domain model and relational tables (in Python or Markdown). The generator produces a typed `*Finder` class per entity. You use those classes to build and run SQL queries without writing SQL directly:
+## Requirements
 
-```typescript
-const tf = new TradeFinder();
+- Node ≥ 24
+- [uv](https://docs.astral.sh/uv/) (Python package manager)
 
-// Filter, join, milestoning applied automatically
-const rows = await tf.findAll(
-  null,                        // business date (null = not applicable)
-  new Date(),                  // processing valid-at (temporal snapshot)
-  [tf.symbol(), tf.price(), tf.account().name()],
-  tf.symbol().eq('AAPL'),
-).toRows();
-```
-
-Temporal filtering (`in_z <= ? AND out_z > ?`) is injected automatically based on the milestoning type declared in the mapping.
-
-## Setup
+## Install
 
 ```bash
 npm install
-
-# Install Python generator dependencies (system-wide, no virtualenv)
-pip3 install jinja2 markdown-it-py
+uv sync       # install Python generator dependencies
 ```
 
-Node ≥ 20 required.
-
 ## Generating finders
 
-Generated files are gitignored — regenerate them before running tests on a fresh clone.
+Generated files are gitignored — regenerate before running tests on a fresh clone.
 
 ```bash
-# From programmatic mapping definitions (example/mappings.py)
-python3 example/generate.py               # → example/generated/
-
-# From a markdown mapping file (finance_mapping.md in sibling data-finder repo)
-python3 example/generate_from_markdown.py # → tests/generated_markdown/
+npm run generate           # from programmatic mappings (example/mappings.py) → example/generated/
+npm run generate:examples  # from all datafinder_examples mappings → tests/generated_examples/
 ```
 
-The generators import directly from the sibling `../data-finder` Python project, which must be present.
+The generator uses the [`data-finder`](https://pypi.org/project/data-finder/) PyPI package (installed via `uv sync`).
 
 ## Running tests
 
 ```bash
-npm test                                        # all tests
-npx vitest run tests/duckdb.test.ts             # single file
-npm run build                                   # type-check only
+npm test                                  # all tests
+npx vitest run tests/duckdb.test.ts       # single file
+npm run build                             # type-check only
+npm run build:lib                         # build distributable (tsup)
 ```
 
-Tests use an in-memory DuckDB instance via `@duckdb/node-api`. `tests/duckdb.test.ts` loads CSV fixtures from `example/data/`; `tests/duckdb-markdown.test.ts` seeds data with INSERT statements.
-
-## Milestoning types
-
-| Type | Mapping class | `findAll` args used |
-|---|---|---|
-| None | — | neither |
-| Processing temporal | `ProcessingDateMilestonesPropertyMapping` | `processingValidAt` |
-| Single business date | `SingleBusinessDateMilestonePropertyMapping` | `businessDate` |
-| Business date + processing | `BusinessDateAndProcessingMilestonePropertyMapping` | both |
-| Bi-temporal | `BiTemporalMilestonePropertyMapping` | both |
+Tests use an in-memory DuckDB instance via `@duckdb/node-api`.
 
 ## Defining a mapping (Markdown)
 
@@ -98,20 +71,9 @@ Tests use an in-memory DuckDB instance via `@duckdb/node-api`. `tests/duckdb.tes
 Load and generate:
 
 ```python
-from mapping_markdown.markdown_mapping import load
+from datafinder_examples.finance_mapping import load
 from ts_generator.generator import generate
 
 mapping = load('my_mapping.md')
 generate(mapping, 'output/')
 ```
-
-## Reverse associations
-
-When a model association is declared (e.g. `Trade → Account`), the generator adds a `trades()` method on `AccountFinder` pointing back to `TradeRelatedFinder`. Because ESM circular imports can't be resolved with static `import`, finders self-register at module load via `registerRelatedFinderClass`. When using a reverse association in tests, import the source finder's module first:
-
-```typescript
-await import('./generated/TradeFinder'); // ensures TradeRelatedFinder is registered
-const { AccountFinder } = await import('./generated/AccountFinder');
-const af = new AccountFinder();
-const rows = await af.findAll(null, null, [af.name(), af.trades().symbol()]).toRows();
-```

package/dist/chunk-BGEX377Q.js

@@ -0,0 +1,230 @@
+import {
+  AggregateOperation,
+  Alias,
+  Column,
+  ColumnWithJoin,
+  InOperation,
+  IsNotNullOperation,
+  IsNullOperation,
+  NotInOperation,
+  ScalarFunctionOperation,
+  SortOperation,
+  WindowFunctionOperation,
+  WindowSpecification
+} from "./chunk-PF6EJZHB.js";
+
+// src/datafinder/attribute.ts
+var Attribute = class _Attribute {
+  _displayName;
+  _column;
+  _owner;
+  _parent;
+  _embedded;
+  _optional;
+  constructor(displayName, columnName, columnDbType, owner, parent, embedded, nullable = true, optional = false) {
+    this._optional = optional;
+    this._displayName = displayName;
+    this._column = new Column(columnName, columnDbType, owner, false, nullable);
+    this._owner = owner;
+    this._parent = parent;
+    this._embedded = embedded;
+  }
+  column() {
+    return this._column;
+  }
+  owner() {
+    return this._owner;
+  }
+  parent() {
+    return this._parent;
+  }
+  displayName() {
+    return this._displayName;
+  }
+  /** Alternate attribute on a flat column of the owning table, used in place of this one when its join is elided. */
+  embedded() {
+    return this._embedded;
+  }
+  /** @internal The expression a function of this attribute applies to: its column. */
+  functionInput() {
+    return this.cwj();
+  }
+  /** @internal What a function of this attribute is labelled after: its display name. */
+  functionLabel() {
+    return this._displayName;
+  }
+  /** @internal This attribute as an operand of arithmetic: its column. */
+  arithmeticOperand() {
+    return this.cwj();
+  }
+  cwj() {
+    return new ColumnWithJoin(this._column, this._parent, this._embedded?.cwj(), this._optional);
+  }
+  /** Count the number of non-null values. Use in a projection with `groupBy` to aggregate per group. */
+  count() {
+    return new AggregateOperation(
+      this.cwj(),
+      "COUNT" /* COUNT */,
+      this._displayName + " Count"
+    );
+  }
+  /** Name this column in the result: `f.price().sum().alias('Total')`. */
+  alias(name) {
+    return new Alias(this, name);
+  }
+  /** The number of different non-NULL values in the group: `COUNT(DISTINCT column)`. Use with `groupBy` to count per group. */
+  countDistinct() {
+    return new AggregateOperation(this.cwj(), "COUNT_DISTINCT" /* COUNT_DISTINCT */, this._displayName + " Count Distinct");
+  }
+  /** The value, or `defaultValue` when it is NULL: `name().orElse('N/A')`. Like `COALESCE` in SQL. */
+  orElse(defaultValue) {
+    if (!["string", "number", "boolean"].includes(typeof defaultValue)) {
+      throw new TypeError(`An orElse default is a string, number or boolean, not ${defaultValue === null ? "null" : typeof defaultValue}`);
+    }
+    return new ScalarFunctionOperation(this.cwj(), "COALESCE" /* COALESCE */, "Or Else " + this._displayName, void 0, [defaultValue]);
+  }
+  /** Sort this attribute in ascending order. Pass to `orderBy` or a window function's `orderBy`. */
+  ascending() {
+    return new SortOperation(this.cwj(), "ASC" /* ASC */);
+  }
+  /** Sort this attribute in descending order. Pass to `orderBy` or a window function's `orderBy`. */
+  descending() {
+    return new SortOperation(this.cwj(), "DESC" /* DESC */);
+  }
+  /** Filter to rows where this attribute has no value. */
+  isNull() {
+    return new IsNullOperation(this.cwj());
+  }
+  /** Filter to rows where this attribute has a value. */
+  isNotNull() {
+    return new IsNotNullOperation(this.cwj());
+  }
+  /** Wrap a value as a constant of this attribute's type. Overridden by the typed attributes. */
+  toConstant(_value) {
+    throw new TypeError(`${this.constructor.name} does not support isIn / isNotIn`);
+  }
+  _constants(values) {
+    const constants = values.map((v) => this.toConstant(v));
+    if (constants.length === 0) throw new Error("isIn / isNotIn need at least one value");
+    return constants;
+  }
+  /** Filter to rows where this attribute equals any of `values`. */
+  isIn(values) {
+    return new InOperation(this.cwj(), this._constants(values));
+  }
+  /** Filter to rows where this attribute equals none of `values`. Rows with no value are excluded, as in SQL. */
+  isNotIn(values) {
+    return new NotInOperation(this.cwj(), this._constants(values));
+  }
+  _windowSpec(partitionBy, orderBy) {
+    const pbArr = partitionBy === void 0 ? [] : Array.isArray(partitionBy) ? partitionBy : [partitionBy];
+    const pb = pbArr.map((x) => x instanceof _Attribute ? x.cwj() : x);
+    const ob = orderBy === void 0 ? [] : Array.isArray(orderBy) ? orderBy : [orderBy];
+    return new WindowSpecification(pb, ob);
+  }
+  /**
+   * Assign a rank to each row within the ordered window, following pandas `Series.rank` conventions.
+   *
+   * `method` controls tie-breaking (default `'min'`):
+   * - `'min'`   — tied rows share the lowest rank; the next rank skips.
+   * - `'dense'` — like `'min'` but ranks are contiguous (no gaps).
+   * - `'first'` — each row gets a unique sequential integer (no ties).
+   * - `'max'`   — only meaningful with `pct: true` (see below).
+   *
+   * When `pct: true` the result is a relative rank between 0 and 1:
+   * - `method: 'min'` (default) → fraction of values strictly below this row (PERCENT_RANK).
+   * - `method: 'max'` → fraction of values at or below this row (cumulative distribution).
+   *
+   * `partitionBy` restarts the ranking within each group of distinct values.
+   */
+  rank(opts = {}) {
+    const { method = "min", pct = false, partitionBy, orderBy } = opts;
+    let func;
+    let name;
+    if (pct) {
+      if (method === "max") {
+        func = "CUME_DIST" /* CUME_DIST */;
+        name = "Cume Dist";
+      } else {
+        func = "PERCENT_RANK" /* PERCENT_RANK */;
+        name = "Percent Rank";
+      }
+    } else if (method === "first") {
+      func = "ROW_NUMBER" /* ROW_NUMBER */;
+      name = "Row Number";
+    } else if (method === "dense") {
+      func = "DENSE_RANK" /* DENSE_RANK */;
+      name = "Dense Rank";
+    } else {
+      func = "RANK" /* RANK */;
+      name = "Rank";
+    }
+    return new WindowFunctionOperation(null, func, name, void 0, [], this._windowSpec(partitionBy, orderBy));
+  }
+  /**
+   * Split rows into `buckets` equal-sized quantile bins ordered by `orderBy`.
+   * Each row receives a bucket number from 1 (lowest) to `buckets` (highest).
+   * Named after `pandas.qcut`.
+   */
+  qcut(buckets, opts = {}) {
+    return new WindowFunctionOperation(
+      null,
+      "NTILE" /* NTILE */,
+      "Quantile",
+      buckets,
+      [],
+      this._windowSpec(opts.partitionBy, opts.orderBy)
+    );
+  }
+  /**
+   * Return the value of this attribute from `periods` rows earlier (positive) or later (negative)
+   * within the ordered window, following `pandas.Series.shift`.
+   * Rows with no neighbour at the given offset return `null` (or `fillValue` if provided).
+   */
+  shift(periods = 1, opts = {}) {
+    const extraArgs = opts.fillValue !== void 0 ? [opts.fillValue] : [];
+    const func = periods >= 0 ? "LAG" /* LAG */ : "LEAD" /* LEAD */;
+    const label = periods >= 0 ? "Lag" : "Lead";
+    return new WindowFunctionOperation(
+      this.cwj(),
+      func,
+      label + " " + this._displayName,
+      Math.abs(periods),
+      extraArgs,
+      this._windowSpec(opts.partitionBy, opts.orderBy)
+    );
+  }
+  /**
+   * Return the first value of this attribute in the window frame.
+   * Use `partitionBy` to restart the frame for each group.
+   */
+  first(opts = {}) {
+    return new WindowFunctionOperation(
+      this.cwj(),
+      "FIRST_VALUE" /* FIRST_VALUE */,
+      "First " + this._displayName,
+      void 0,
+      [],
+      this._windowSpec(opts.partitionBy, opts.orderBy)
+    );
+  }
+  /**
+   * Return the last value of this attribute in the window frame.
+   * Use `partitionBy` to restart the frame for each group.
+   */
+  last(opts = {}) {
+    return new WindowFunctionOperation(
+      this.cwj(),
+      "LAST_VALUE" /* LAST_VALUE */,
+      "Last " + this._displayName,
+      void 0,
+      [],
+      this._windowSpec(opts.partitionBy, opts.orderBy)
+    );
+  }
+};
+
+export {
+  Attribute
+};
+//# sourceMappingURL=chunk-BGEX377Q.js.map

package/dist/chunk-BGEX377Q.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/datafinder/attribute.ts"],"sourcesContent":["import {\n  Column,\n  AggregateOperation,\n  AggregateOperator,\n  ColumnWithJoin,\n  SortOperation,\n  SortDirection,\n  IsNullOperation,\n  IsNotNullOperation,\n  InOperation,\n  NotInOperation,\n  ConstantOperation,\n  JoinTreeNodeOperation,\n  Alias,\n  RelationalOperationElement,\n  Aliasable,\n  ScalarFunction,\n  ScalarFunctionOperation,\n  WindowFunction,\n  WindowFunctionOperation,\n  WindowSpecification,\n} from '../model/relational';\n\n/** A value an attribute can be compared with in `isIn` / `isNotIn`. */\nexport type AttributeValue = string | number | boolean | Date;\n\nexport abstract class Attribute implements Aliasable {\n  private readonly _displayName: string;\n  private readonly _column: Column;\n  private readonly _owner: string;\n  private readonly _parent?: JoinTreeNodeOperation;\n  private readonly _embedded?: Attribute;\n  private readonly _optional: boolean;\n\n  constructor(\n    displayName: string,\n    columnName: string,\n    columnDbType: string,\n    owner: string,\n    parent?: JoinTreeNodeOperation,\n    embedded?: Attribute,\n    nullable: boolean = true,\n    optional: boolean = false,\n  ) {\n    this._optional = optional;\n    this._displayName = displayName;\n    this._column = new Column(columnName, columnDbType, owner, false, nullable);\n    this._owner = owner;\n    this._parent = parent;\n    this._embedded = embedded;\n  }\n\n  column(): Column { return this._column; }\n  owner(): string { return this._owner; }\n  parent(): JoinTreeNodeOperation | undefined { return this._parent; }\n  displayName(): string { return this._displayName; }\n\n  /** Alternate attribute on a flat column of the owning table, used in place of this one when its join is elided. */\n  embedded(): Attribute | undefined { return this._embedded; }\n\n  /** @internal The expression a function of this attribute applies to: its column. */\n  functionInput(): RelationalOperationElement {\n    return this.cwj();\n  }\n\n  /** @internal What a function of this attribute is labelled after: its display name. */\n  functionLabel(): string {\n    return this._displayName;\n  }\n\n  /** @internal This attribute as an operand of arithmetic: its column. */\n  arithmeticOperand(): RelationalOperationElement {\n    return this.cwj();\n  }\n\n  cwj(): ColumnWithJoin {\n    return new ColumnWithJoin(this._column, this._parent, this._embedded?.cwj(), this._optional);\n  }\n\n  /** Count the number of non-null values. Use in a projection with `groupBy` to aggregate per group. */\n  count(): AggregateOperation {\n    return new AggregateOperation(\n      this.cwj(),\n      AggregateOperator.COUNT,\n      this._displayName + ' Count',\n    );\n  }\n\n  /** Name this column in the result: `f.price().sum().alias('Total')`. */\n  alias(name: string): Alias {\n    return new Alias(this, name);\n  }\n\n  /** The number of different non-NULL values in the group: `COUNT(DISTINCT column)`. Use with `groupBy` to count per group. */\n  countDistinct(): AggregateOperation {\n    return new AggregateOperation(this.cwj(), AggregateOperator.COUNT_DISTINCT, this._displayName + ' Count Distinct');\n  }\n\n  /** The value, or `defaultValue` when it is NULL: `name().orElse('N/A')`. Like `COALESCE` in SQL. */\n  orElse(defaultValue: string | number | boolean): ScalarFunctionOperation {\n    if (!['string', 'number', 'boolean'].includes(typeof defaultValue)) {\n      throw new TypeError(`An orElse default is a string, number or boolean, not ${defaultValue === null ? 'null' : typeof defaultValue}`);\n    }\n    return new ScalarFunctionOperation(this.cwj(), ScalarFunction.COALESCE, 'Or Else ' + this._displayName, undefined, [defaultValue]);\n  }\n\n  /** Sort this attribute in ascending order. Pass to `orderBy` or a window function's `orderBy`. */\n  ascending(): SortOperation {\n    return new SortOperation(this.cwj(), SortDirection.ASC);\n  }\n\n  /** Sort this attribute in descending order. Pass to `orderBy` or a window function's `orderBy`. */\n  descending(): SortOperation {\n    return new SortOperation(this.cwj(), SortDirection.DESC);\n  }\n\n  /** Filter to rows where this attribute has no value. */\n  isNull(): IsNullOperation {\n    return new IsNullOperation(this.cwj());\n  }\n\n  /** Filter to rows where this attribute has a value. */\n  isNotNull(): IsNotNullOperation {\n    return new IsNotNullOperation(this.cwj());\n  }\n\n  /** Wrap a value as a constant of this attribute's type. Overridden by the typed attributes. */\n  protected toConstant(_value: AttributeValue): ConstantOperation {\n    throw new TypeError(`${this.constructor.name} does not support isIn / isNotIn`);\n  }\n\n  private _constants(values: readonly AttributeValue[]): ConstantOperation[] {\n    const constants = values.map(v => this.toConstant(v));\n    if (constants.length === 0) throw new Error('isIn / isNotIn need at least one value');\n    return constants;\n  }\n\n  /** Filter to rows where this attribute equals any of `values`. */\n  isIn(values: readonly AttributeValue[]): InOperation {\n    return new InOperation(this.cwj(), this._constants(values));\n  }\n\n  /** Filter to rows where this attribute equals none of `values`. Rows with no value are excluded, as in SQL. */\n  isNotIn(values: readonly AttributeValue[]): NotInOperation {\n    return new NotInOperation(this.cwj(), this._constants(values));\n  }\n\n  private _windowSpec(\n    partitionBy?: Attribute | ColumnWithJoin | (Attribute | ColumnWithJoin)[],\n    orderBy?: SortOperation | SortOperation[],\n  ): WindowSpecification {\n    const pbArr = partitionBy === undefined ? [] : Array.isArray(partitionBy) ? partitionBy : [partitionBy];\n    const pb = pbArr.map(x => x instanceof Attribute ? x.cwj() : x);\n    const ob = orderBy === undefined ? [] : Array.isArray(orderBy) ? orderBy : [orderBy];\n    return new WindowSpecification(pb, ob);\n  }\n\n  /**\n   * Assign a rank to each row within the ordered window, following pandas `Series.rank` conventions.\n   *\n   * `method` controls tie-breaking (default `'min'`):\n   * - `'min'`   — tied rows share the lowest rank; the next rank skips.\n   * - `'dense'` — like `'min'` but ranks are contiguous (no gaps).\n   * - `'first'` — each row gets a unique sequential integer (no ties).\n   * - `'max'`   — only meaningful with `pct: true` (see below).\n   *\n   * When `pct: true` the result is a relative rank between 0 and 1:\n   * - `method: 'min'` (default) → fraction of values strictly below this row (PERCENT_RANK).\n   * - `method: 'max'` → fraction of values at or below this row (cumulative distribution).\n   *\n   * `partitionBy` restarts the ranking within each group of distinct values.\n   */\n  rank(opts: {\n    method?: 'min' | 'dense' | 'first' | 'max';\n    pct?: boolean;\n    partitionBy?: Attribute | ColumnWithJoin | (Attribute | ColumnWithJoin)[];\n    orderBy?: SortOperation | SortOperation[];\n  } = {}): WindowFunctionOperation {\n    const { method = 'min', pct = false, partitionBy, orderBy } = opts;\n    let func: WindowFunction;\n    let name: string;\n    if (pct) {\n      if (method === 'max') { func = WindowFunction.CUME_DIST; name = 'Cume Dist'; }\n      else { func = WindowFunction.PERCENT_RANK; name = 'Percent Rank'; }\n    } else if (method === 'first') { func = WindowFunction.ROW_NUMBER; name = 'Row Number'; }\n    else if (method === 'dense') { func = WindowFunction.DENSE_RANK; name = 'Dense Rank'; }\n    else { func = WindowFunction.RANK; name = 'Rank'; }\n    return new WindowFunctionOperation(null, func, name, undefined, [], this._windowSpec(partitionBy, orderBy));\n  }\n\n  /**\n   * Split rows into `buckets` equal-sized quantile bins ordered by `orderBy`.\n   * Each row receives a bucket number from 1 (lowest) to `buckets` (highest).\n   * Named after `pandas.qcut`.\n   */\n  qcut(buckets: number, opts: {\n    partitionBy?: Attribute | ColumnWithJoin | (Attribute | ColumnWithJoin)[];\n    orderBy?: SortOperation | SortOperation[];\n  } = {}): WindowFunctionOperation {\n    return new WindowFunctionOperation(null, WindowFunction.NTILE, 'Quantile', buckets, [],\n      this._windowSpec(opts.partitionBy, opts.orderBy));\n  }\n\n  /**\n   * Return the value of this attribute from `periods` rows earlier (positive) or later (negative)\n   * within the ordered window, following `pandas.Series.shift`.\n   * Rows with no neighbour at the given offset return `null` (or `fillValue` if provided).\n   */\n  shift(periods = 1, opts: {\n    fillValue?: string | number;\n    partitionBy?: Attribute | ColumnWithJoin | (Attribute | ColumnWithJoin)[];\n    orderBy?: SortOperation | SortOperation[];\n  } = {}): WindowFunctionOperation {\n    const extraArgs: (string | number)[] = opts.fillValue !== undefined ? [opts.fillValue] : [];\n    const func = periods >= 0 ? WindowFunction.LAG : WindowFunction.LEAD;\n    const label = periods >= 0 ? 'Lag' : 'Lead';\n    return new WindowFunctionOperation(\n      this.cwj(),\n      func,\n      label + ' ' + this._displayName,\n      Math.abs(periods),\n      extraArgs,\n      this._windowSpec(opts.partitionBy, opts.orderBy),\n    );\n  }\n\n  /**\n   * Return the first value of this attribute in the window frame.\n   * Use `partitionBy` to restart the frame for each group.\n   */\n  first(opts: {\n    partitionBy?: Attribute | ColumnWithJoin | (Attribute | ColumnWithJoin)[];\n    orderBy?: SortOperation | SortOperation[];\n  } = {}): WindowFunctionOperation {\n    return new WindowFunctionOperation(\n      this.cwj(),\n      WindowFunction.FIRST_VALUE,\n      'First ' + this._displayName,\n      undefined, [],\n      this._windowSpec(opts.partitionBy, opts.orderBy),\n    );\n  }\n\n  /**\n   * Return the last value of this attribute in the window frame.\n   * Use `partitionBy` to restart the frame for each group.\n   */\n  last(opts: {\n    partitionBy?: Attribute | ColumnWithJoin | (Attribute | ColumnWithJoin)[];\n    orderBy?: SortOperation | SortOperation[];\n  } = {}): WindowFunctionOperation {\n    return new WindowFunctionOperation(\n      this.cwj(),\n      WindowFunction.LAST_VALUE,\n      'Last ' + this._displayName,\n      undefined, [],\n      this._windowSpec(opts.partitionBy, opts.orderBy),\n    );\n  }\n}\n"],"mappings":"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","names":[]}