@jd-data-limited/easy-fm 5.0.0-beta.1 → 5.0.0-beta.4

package/dist/typegen/types.d.ts

@@ -0,0 +1,40 @@
+import type { ApiFieldResultTypes, ApiFieldTypes } from '../models/apiResults.js';
+export interface TypegenField {
+    name: string;
+    result: typeof ApiFieldResultTypes[keyof typeof ApiFieldResultTypes];
+    type: typeof ApiFieldTypes[keyof typeof ApiFieldTypes];
+    writable: boolean;
+    required: boolean;
+}
+export interface TypegenLayout {
+    name: string;
+    clientName?: string;
+    fields: TypegenField[];
+    portals: Record<string, TypegenField[]>;
+}
+export interface TypegenSchema {
+    version: 1;
+    layouts: TypegenLayout[];
+}
+export type TypegenTransport = 'data-api' | 'odata';
+export interface SchemaSource {
+    introspect(): Promise<TypegenSchema>;
+}
+/** Code-generation plugin for a runtime validation library. */
+export interface TypegenValidator {
+    readonly imports: readonly string[];
+    readonly runtimeValidator: string;
+    /** Render a validator for the complete canonical ProviderRecord. */
+    renderRecord(layout: TypegenLayout): string;
+}
+export interface TypegenConfig {
+    source: SchemaSource;
+    output: string;
+    /** Placeholder describing intended runtime transports. */
+    transports?: TypegenTransport[];
+    /** Restrict output to these FileMaker layout names. */
+    layouts?: string[];
+    /** Defaults to the built-in strict Zod validator. */
+    validator?: TypegenValidator;
+}
+export declare function defineTypegenConfig(config: TypegenConfig): TypegenConfig;

package/dist/typegen/types.js

@@ -0,0 +1 @@
+export function defineTypegenConfig(config) { return config; }

package/dist/typegen/zod.d.ts

@@ -0,0 +1,3 @@
+import type { TypegenValidator } from './types.js';
+/** Strict Zod generator. Extra, missing, and wrongly typed fields fail validation. */
+export declare function zodTypegenValidator(): TypegenValidator;

package/dist/typegen/zod.js

@@ -0,0 +1,32 @@
+/** Strict Zod generator. Extra, missing, and wrongly typed fields fail validation. */
+export function zodTypegenValidator() {
+    return {
+        imports: ["import {z} from 'zod'"],
+        runtimeValidator: 'zodValidator',
+        renderRecord: renderProviderRecord
+    };
+}
+function renderProviderRecord(layout) {
+    const fieldData = objectSchema(layout.fields);
+    const portals = Object.entries(layout.portals).map(([name, fields]) => `${quote(name)}: z.array(${portalRowSchema(fields)})`).join(', ');
+    const portalData = `z.object({${portals}}).partial().strict().optional()`;
+    return `z.object({recordId: z.string(), modId: z.string(), fieldData: ${fieldData}, portalData: ${portalData}}).strict()`;
+}
+function objectSchema(fields) {
+    return `z.object({${fields.map(field => `${quote(field.name)}: ${fieldSchema(field)}`).join(', ')}}).strict()`;
+}
+function portalRowSchema(fields) {
+    const entries = fields.map(field => `${quote(field.name)}: ${fieldSchema(field)}`);
+    entries.push('recordId: z.union([z.string(), z.number()])', 'modId: z.union([z.string(), z.number()])');
+    return `z.object({${entries.join(', ')}}).strict()`;
+}
+function fieldSchema(field) {
+    if (field.result === 'number')
+        return 'z.number().nullable()';
+    if (field.result === 'date' || field.result === 'time' || field.result === 'timeStamp')
+        return 'z.string().nullable()';
+    if (field.result === 'container')
+        return 'z.string().nullable()';
+    return 'z.string()';
+}
+function quote(value) { return JSON.stringify(value); }

package/dist/types.d.ts

@@ -2,7 +2,7 @@ import type * as http from 'http';
 import { type FMError } from './FMError.js';
 import { type LayoutInterface } from './layouts/layoutInterface.js';
 import z from "zod";
-export type PickPortals<LAYOUT extends LayoutInterface, PORTALS extends string | number | symbol = ''> = Omit<LAYOUT, 'portals'> & {
+export type PickPortals<LAYOUT extends LayoutInterface, PORTALS extends keyof LAYOUT['portals'] = never> = Omit<LAYOUT, 'portals'> & {
     portals: Pick<LAYOUT['portals'], PORTALS>;
 };
 /** Shared database connection options. */

package/dist/utils/query.d.ts

@@ -1,23 +1,32 @@
-import { type Moment } from 'moment';
+import { Temporal } from 'temporal-polyfill';
 export declare const FindRequestSymbol: unique symbol;
-/** Represents a date, time, or timestamp value passed into `query(...)`. */
-export interface TimestampType {
-    type: 'date' | 'time' | 'timestamp';
-    moment: Moment;
-}
+export type TimestampType = Temporal.PlainDate | Temporal.PlainTime | Temporal.PlainDateTime;
 type QueryParameter = string | number | TimestampType;
 /** Represents a FileMaker find value produced by `query(...)`. */
 export interface Query {
     [FindRequestSymbol]: Array<string | TimestampType>;
 }
+type LegacyDateLike = {
+    toDate: () => Date;
+};
+type DateInput = Date | LegacyDateLike;
+/**
+ * Converts a JavaScript Date or legacy Moment-like value to a Temporal date.
+ * @deprecated Construct a `Temporal.PlainDate` directly instead.
+ */
+export declare function asDate(value: DateInput | Temporal.PlainDate | Temporal.PlainDateTime): Temporal.PlainDate;
+/**
+ * Converts a JavaScript Date or legacy Moment-like value to a Temporal time.
+ * @deprecated Construct a `Temporal.PlainTime` directly instead.
+ */
+export declare function asTime(value: DateInput | Temporal.PlainTime | Temporal.PlainDateTime): Temporal.PlainTime;
+/**
+ * Converts a JavaScript Date or legacy Moment-like value to a Temporal timestamp.
+ * @deprecated Construct a `Temporal.PlainDateTime` directly instead.
+ */
+export declare function asTimestamp(value: DateInput | Temporal.PlainDateTime): Temporal.PlainDateTime;
 /** Escapes special characters in a raw FileMaker find string. */
 export declare function queryEscape(str: string): string;
 /** Builds a FileMaker find value using template-string syntax. */
 export declare function query(strings: TemplateStringsArray, ...args: QueryParameter[]): Query;
-/** Marks a value as a FileMaker date for use inside `query(...)`. */
-export declare function asDate(date: Date | Moment): TimestampType;
-/** Marks a value as a FileMaker time for use inside `query(...)`. */
-export declare function asTime(date: Date | Moment): TimestampType;
-/** Marks a value as a FileMaker timestamp for use inside `query(...)`. */
-export declare function asTimestamp(date: Date | Moment): TimestampType;
 export {};

package/dist/utils/query.js

@@ -1,9 +1,66 @@
 /*
  * Copyright (c) 2024. See LICENSE file for more information
  */
-import moment from 'moment';
+import { Temporal } from 'temporal-polyfill';
 export const FindRequestSymbol = Symbol('easyfm-findrequest');
 const SPECIAL_CHARACTERS = ['\\', '=', '<', '≤', '≥', '>', '…', '...', '//', '@', '#', '*', '"', '~'];
+function toDate(value) {
+    const date = value instanceof Date ? value : value.toDate();
+    if (Number.isNaN(date.getTime()))
+        throw new RangeError('Invalid date value');
+    return date;
+}
+/**
+ * Converts a JavaScript Date or legacy Moment-like value to a Temporal date.
+ * @deprecated Construct a `Temporal.PlainDate` directly instead.
+ */
+export function asDate(value) {
+    if (value instanceof Temporal.PlainDate)
+        return value;
+    if (value instanceof Temporal.PlainDateTime)
+        return value.toPlainDate();
+    const date = toDate(value);
+    return Temporal.PlainDate.from({
+        year: date.getFullYear(),
+        month: date.getMonth() + 1,
+        day: date.getDate()
+    });
+}
+/**
+ * Converts a JavaScript Date or legacy Moment-like value to a Temporal time.
+ * @deprecated Construct a `Temporal.PlainTime` directly instead.
+ */
+export function asTime(value) {
+    if (value instanceof Temporal.PlainTime)
+        return value;
+    if (value instanceof Temporal.PlainDateTime)
+        return value.toPlainTime();
+    const date = toDate(value);
+    return Temporal.PlainTime.from({
+        hour: date.getHours(),
+        minute: date.getMinutes(),
+        second: date.getSeconds(),
+        millisecond: date.getMilliseconds()
+    });
+}
+/**
+ * Converts a JavaScript Date or legacy Moment-like value to a Temporal timestamp.
+ * @deprecated Construct a `Temporal.PlainDateTime` directly instead.
+ */
+export function asTimestamp(value) {
+    if (value instanceof Temporal.PlainDateTime)
+        return value;
+    const date = toDate(value);
+    return Temporal.PlainDateTime.from({
+        year: date.getFullYear(),
+        month: date.getMonth() + 1,
+        day: date.getDate(),
+        hour: date.getHours(),
+        minute: date.getMinutes(),
+        second: date.getSeconds(),
+        millisecond: date.getMilliseconds()
+    });
+}
 /** Escapes special characters in a raw FileMaker find string. */
 export function queryEscape(str) {
     for (const char of SPECIAL_CHARACTERS) {
@@ -28,25 +85,3 @@ export function query(strings, ...args) {
     }).flat(1);
     return { [FindRequestSymbol]: query };
 }
-/** Marks a value as a FileMaker date for use inside `query(...)`. */
-export function asDate(date) {
-    return {
-        type: 'date',
-        moment: moment(date)
-    };
-}
-/** Marks a value as a FileMaker time for use inside `query(...)`. */
-export function asTime(date) {
-    return {
-        type: 'time',
-        moment: moment(date)
-    };
-}
-/** Marks a value as a FileMaker timestamp for use inside `query(...)`. */
-export function asTimestamp(date) {
-    return {
-        type: 'timestamp',
-        moment: moment(date)
-    };
-}
-query;

package/dist/utils/temporal.d.ts

@@ -0,0 +1,9 @@
+import { Temporal } from 'temporal-polyfill';
+export type TemporalValue = Temporal.PlainDate | Temporal.PlainTime | Temporal.PlainDateTime;
+export type TemporalValueType = 'date' | 'time' | 'timestamp';
+/** Formats a Temporal value using the supplied token-based format. */
+export declare function temporalToString(value: TemporalValue, format: string): string;
+export declare function stringToTemporal(value: string, type: 'date', format: string): Temporal.PlainDate;
+export declare function stringToTemporal(value: string, type: 'time', format: string): Temporal.PlainTime;
+export declare function stringToTemporal(value: string, type: 'timestamp', format: string): Temporal.PlainDateTime;
+export declare function stringToTemporal(value: string, type: TemporalValueType, format: string): TemporalValue;

package/dist/utils/temporal.js

@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) 2023-2024. See LICENSE file for more information
+ */
+import { Temporal } from 'temporal-polyfill';
+const FORMAT_TOKEN_PATTERN = /yyyy|MM|dd|HH|mm|ss/g;
+const TOKEN_PATTERNS = {
+    yyyy: '\\d{4}',
+    MM: '\\d{2}',
+    dd: '\\d{2}',
+    HH: '\\d{2}',
+    mm: '\\d{2}',
+    ss: '\\d{2}'
+};
+function normalizeFormat(format) {
+    return format.replace(/YYYY/g, 'yyyy').replace(/DD/g, 'dd');
+}
+function pad(value, length = 2) {
+    return value.toString().padStart(length, '0');
+}
+function invalidTemporalString(value, format) {
+    throw new RangeError(`Invalid Temporal value ${JSON.stringify(value)}; expected ${format}`);
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function tokensIn(format) {
+    const tokens = format.match(FORMAT_TOKEN_PATTERN);
+    if (!tokens)
+        throw new RangeError(`Format ${JSON.stringify(format)} contains no supported tokens`);
+    if (new Set(tokens).size !== tokens.length) {
+        throw new RangeError(`Format ${JSON.stringify(format)} contains duplicate tokens`);
+    }
+    return tokens;
+}
+function parserFor(format) {
+    const tokens = tokensIn(format);
+    let source = '^';
+    let lastIndex = 0;
+    for (const match of format.matchAll(FORMAT_TOKEN_PATTERN)) {
+        source += escapeRegExp(format.slice(lastIndex, match.index));
+        source += `(${TOKEN_PATTERNS[match[0]]})`;
+        lastIndex = match.index + match[0].length;
+    }
+    source += `${escapeRegExp(format.slice(lastIndex))}$`;
+    return { pattern: new RegExp(source), tokens };
+}
+/** Formats a Temporal value using the supplied token-based format. */
+export function temporalToString(value, format) {
+    format = normalizeFormat(format);
+    const values = {};
+    if (value instanceof Temporal.PlainDateTime) {
+        Object.assign(values, {
+            yyyy: pad(value.year, 4), MM: pad(value.month), dd: pad(value.day),
+            HH: pad(value.hour), mm: pad(value.minute), ss: pad(value.second)
+        });
+    }
+    else if (value instanceof Temporal.PlainDate) {
+        Object.assign(values, { yyyy: pad(value.year, 4), MM: pad(value.month), dd: pad(value.day) });
+    }
+    else if (value instanceof Temporal.PlainTime) {
+        Object.assign(values, { HH: pad(value.hour), mm: pad(value.minute), ss: pad(value.second) });
+    }
+    else {
+        throw new TypeError('Expected a Temporal.PlainDate, Temporal.PlainTime, or Temporal.PlainDateTime');
+    }
+    tokensIn(format).forEach(token => {
+        if (values[token] === undefined)
+            throw new RangeError(`Token ${token} is not available for this Temporal type`);
+    });
+    return format.replace(FORMAT_TOKEN_PATTERN, token => values[token]);
+}
+/** Parses a Temporal value using the supplied token-based format. */
+export function stringToTemporal(value, type, format) {
+    format = normalizeFormat(format);
+    const { pattern, tokens } = parserFor(format);
+    const match = pattern.exec(value);
+    if (!match)
+        return invalidTemporalString(value, format);
+    const parts = Object.fromEntries(tokens.map((token, index) => [token, Number(match[index + 1])]));
+    const required = type === 'date'
+        ? ['yyyy', 'MM', 'dd']
+        : type === 'time'
+            ? ['HH', 'mm', 'ss']
+            : ['yyyy', 'MM', 'dd', 'HH', 'mm', 'ss'];
+    if (tokens.length !== required.length || required.some(token => parts[token] === undefined)) {
+        throw new RangeError(`Format ${JSON.stringify(format)} does not match Temporal type ${type}`);
+    }
+    if (type === 'date') {
+        return Temporal.PlainDate.from({
+            year: parts.yyyy,
+            month: parts.MM,
+            day: parts.dd
+        }, { overflow: 'reject' });
+    }
+    else if (type === 'time') {
+        return Temporal.PlainTime.from({
+            hour: parts.HH,
+            minute: parts.mm,
+            second: parts.ss
+        }, { overflow: 'reject' });
+    }
+    return Temporal.PlainDateTime.from({
+        year: parts.yyyy,
+        month: parts.MM,
+        day: parts.dd,
+        hour: parts.HH,
+        minute: parts.mm,
+        second: parts.ss
+    }, { overflow: 'reject' });
+}

package/package.json

@@ -1,13 +1,27 @@
 {
   "name": "@jd-data-limited/easy-fm",
-  "version": "5.0.0-beta.1",
+  "version": "5.0.0-beta.4",
   "dependencies": {
-    "commander": "^14.0.3",
-    "moment": "^2.30.1",
-    "zod": "^4.4.3"
+    "chalk": "^5.6.2",
+    "commander": "^15.0.0",
+    "inquirer": "^14.2.2",
+    "temporal-polyfill": "^1.0.5",
+    "zod": "^4.6.5"
   },
   "type": "module",
   "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./typegen": {
+      "types": "./dist/typegen/index.d.ts",
+      "import": "./dist/typegen/index.js"
+    }
+  },
   "module": "es2022",
   "homepage": "https://jd-data.com/project/easyfm/",
   "url": "https://github.com/JD-Data-Limited/easy-fm",
@@ -40,41 +54,50 @@
     "node": ">=22.22.3"
   },
   "devDependencies": {
-    "@babel/cli": "^7.29.7",
-    "@babel/core": "^7.29.7",
-    "@babel/preset-env": "^7.29.7",
-    "@babel/preset-typescript": "^7.29.7",
+    "@babel/cli": "^8.0.6",
+    "@babel/core": "^8.0.6",
+    "@babel/preset-env": "^8.0.6",
+    "@babel/preset-typescript": "^8.0.1",
+    "@cloudflare/vitest-plugin": "^1.2.2",
     "@types/btoa": "^1.2.5",
     "@types/events": "^3.0.3",
     "@types/inquirer": "^9.0.10",
-    "@types/jest": "^29.5.14",
-    "@types/node": "^22.19.21",
-    "@typescript-eslint/eslint-plugin": "^6.21.0",
-    "babel-jest": "^29.7.0",
-    "dotenv": "^16.6.1",
-    "eslint": "^8.57.1",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^26.6.2",
+    "@typescript-eslint/eslint-plugin": "^8.70.1",
+    "babel-jest": "^30.5.2",
+    "dotenv": "^18.0.2",
+    "eslint": "^10.11.0",
     "eslint-config-standard-with-typescript": "^43.0.1",
     "eslint-plugin-import": "^2.32.0",
-    "eslint-plugin-n": "^16.6.2",
-    "eslint-plugin-promise": "^6.6.0",
-    "inquirer": "^9.3.8",
-    "jest": "^29.7.0",
-    "ts-jest": "^29.4.11",
-    "ts-morph": "^21.0.1",
-    "tsx": "^4.22.4",
-    "typedoc": "^0.28.19",
-    "typescript": "^5.9.3"
+    "eslint-plugin-n": "^18.3.0",
+    "eslint-plugin-promise": "^7.3.0",
+    "jest": "^30.5.2",
+    "ts-jest": "^29.4.12",
+    "ts-morph": "^28.0.0",
+    "tsx": "^4.23.15",
+    "typedoc": "^0.28.20",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.11"
   },
   "bin": {
     "easyfm": "dist/bin/cli.js"
   },
+  "publishConfig": {
+    "access": "public"
+  },
   "scripts": {
     "build": "tsc",
     "test": "npm run build && jest",
+    "test:types": "tsc --project tsconfig.test.json",
     "test:coverage": "jest --coverage --testPathIgnorePatterns='/__tests__/database.test.ts$'",
     "test:integration": "npm run build && jest __tests__/database.test.ts --runInBand",
     "test:unit": "jest __tests__/query.test.ts __tests__/CookieJar.test.ts --runInBand",
+    "test:runtime": "pnpm build && pnpm test:runtime:bun && pnpm test:runtime:deno && pnpm test:runtime:workers",
+    "test:runtime:bun": "bun test ./runtime-tests/bun.test.ts",
+    "test:runtime:deno": "deno test --no-check --allow-read --node-modules-dir=manual ./runtime-tests/deno.test.ts",
+    "test:runtime:workers": "vitest run --config ./runtime-tests/workers/vitest.config.ts",
     "stress:search": "tsx src/bin/stressSearch.ts",
-    "docs:build": "typedoc --options ./docs/theme.json"
+    "docs:build": "typedoc --options ../../docs/theme.json"
   }
 }

package/dist/layouts/recordFieldsMap.d.ts

@@ -1,2 +0,0 @@
-import { type Field, type FieldValue } from '../records/field.js';
-export type RecordFieldsMap = Record<string, Field<FieldValue>>;

package/dist/layouts/recordFieldsMap.js

@@ -1,4 +0,0 @@
-/*
- * Copyright (c) 2023-2024. See LICENSE file for more information
- */
-export {};

package/dist/records/field.d.ts

@@ -1,77 +0,0 @@
-import { RecordTypes } from '../types.js';
-import { type ApiFieldMetadata } from '../models/apiResults.js';
-import { type LayoutBase } from '../layouts/layoutBase.js';
-import { type Moment } from 'moment';
-import { Readable } from 'node:stream';
-import { type z } from 'zod';
-export type FieldValue = string | number | Moment | Container;
-export type Container = null;
-export interface Parentable {
-    layout: LayoutBase;
-    type: RecordTypes;
-    endpoint: string;
-    portal?: {
-        name: string;
-    };
-}
-interface StreamOptions {
-    abortSignal?: AbortSignal;
-}
-/**
- * A class representing a field in a record.
- *
- * @template T - The type of the field value.
- */
-export declare class Field<T extends FieldValue> {
-    #private;
-    parent: Parentable;
-    id: string;
-    protected _value: T | null;
-    static firstContainerDownload: Promise<any> | null;
-    constructor(record: Parentable, id: string, originalContents: T);
-    /** `true` if this field has changed since it was last loaded or saved. */
-    get edited(): boolean;
-    /**
-     * Resets the 'edited' state of this field, without changing its value
-     */
-    updateOriginalContents(): void;
-    /**
-     * Sets the value of the field.
-     *
-     * @param {T | null} content - The new content value to be set. Can be either the type T or null.
-     * @throws {Error} Cannot set container value using set(). Use upload() instead, if the result is a 'container'.
-     */
-    set(content: T | null): void;
-    /** Returns the FileMaker metadata for this field. */
-    get metadata(): z.infer<typeof ApiFieldMetadata>;
-    /** Gets or sets the current field value. */
-    get value(): T | null;
-    set value(value: T);
-    /** Returns this field value as a string. Throws if the value is not a string. */
-    get string(): string;
-    /**
-     * Uploads a file to the container field.
-     *
-     * @param {Buffer} file - The file content as a buffer.
-     *
-     * @throws {Error} - Cannot upload a file to the field if it's not a container field.
-     * @throws {Error} - Upload failed with HTTP error.
-     *
-     * @returns {Promise<void>} - A promise that resolves when the file is successfully uploaded.
-     */
-    upload(file: File): Promise<void>;
-    stream(): Promise<{
-        data: Readable;
-        mime: string;
-    }>;
-    /**
-     * Returns the container download as a Web `Response`.
-     */
-    webStream(options: StreamOptions): Promise<Response>;
-    /** Downloads the full container contents into memory. */
-    arrayBuffer(): Promise<{
-        data: ArrayBuffer;
-        mime: string;
-    }>;
-}
-export {};