Infer int timestamps (#18)

* infer timestamps from int + test file

* fix typo

* replace string typecast with recursive call

Author: David Haven

src/@types.ts

@@ -1,4 +1,4 @@
-import { JSONStringFormat, JSONObjectFormat } from "./formats";
+import { JSONStringFormat, JSONObjectFormat, JSONIntFormat } from "./formats";
 
 export type JSONNullType = {
   name: "null";
@@ -17,6 +17,7 @@ export type JSONFloatType = {
 
 export type JSONIntType = {
   name: "int";
+  format?: JSONIntFormat;
   value: number;
 };
 

src/formats/index.ts

@@ -119,3 +119,19 @@ export function inferObjectFormat(value: object): JSONObjectFormat | undefined {
 
   return undefined;
 }
+
+export type JSONIntFormat = JSONTimestampFormat
+
+const intFormats = [inferTimestamp];
+
+export function inferIntFormat(value: number): JSONIntFormat | undefined {
+  for (const [, format] of Object.entries(intFormats)) {
+    const result = format(value);
+
+    if (result) {
+      return result;
+    }
+  }
+
+  return undefined;
+}

src/formats/timestamp.ts

@@ -18,7 +18,10 @@ function inRangeOfNow(msSinceEpoch: number): boolean {
   return now >= lowerBound && now <= upperBound;
 }
 
-export function inferTimestamp(value: string): JSONTimestampFormat | undefined {
+export function inferTimestamp(value: string | number): JSONTimestampFormat | undefined {
+  if (typeof value === "number") {
+    return inferTimestamp(`${value}`);
+  }
   if (timestampSecondsSinceEpoch.test(value)) {
     const seconds = parseInt(value);
 

src/index.ts

@@ -1,5 +1,5 @@
 import { JSONValueType } from "./@types";
-import { inferFormat, inferObjectFormat } from "./formats";
+import { inferFormat, inferObjectFormat, inferIntFormat } from "./formats";
 
 export { JSONValueType };
 export {
@@ -45,7 +45,11 @@ export function inferType(value: unknown): JSONValueType {
 
   if (typeof value === "number") {
     if (Number.isInteger(value)) {
-      return { name: "int", value };
+      return { 
+        name: "int", 
+        value,
+        format: inferIntFormat(value),
+      };
     } else {
       return { name: "float", value };
     }

tests/intFormats.test.ts

@@ -0,0 +1,51 @@
+import { inferType } from "../src";
+
+describe("timestamps", () => {
+  test.each([1664976736123, 1664976736567])(
+    "%p should be inferred as an timestamp",
+    (value) => {
+      expect(inferType(value)).toEqual({
+        name: "int",
+        value,
+        format: {
+          name: "timestamp",
+          variant: "millisecondsSinceEpoch",
+        },
+      });
+    },
+  );
+
+  test.each([1664976736, 1664976736])("%p should be inferred as an timestamp", (value) => {
+    expect(inferType(value)).toEqual({
+      name: "int",
+      value,
+      format: {
+        name: "timestamp",
+        variant: "secondsSinceEpoch",
+      },
+    });
+  });
+
+  test.each([1664976736946364285])("%p should be inferred as an timestamp", (value) => {
+    expect(inferType(value)).toEqual({
+      name: "int",
+      value,
+      format: {
+        name: "timestamp",
+        variant: "nanosecondsSinceEpoch",
+      },
+    });
+  });
+});
+
+describe("without format", () => {
+  test.each([46, 2244994945, 1212092628029698048])(
+    "%p should be inferred as having no format",
+    (value) => {
+      expect(inferType(value)).toEqual({
+        name: "int",
+        value,
+      });
+    },
+  );
+});

tests/stringFormats.test.ts

@@ -162,7 +162,7 @@ describe("rfc2822", () => {
 });
 
 describe("timestamps", () => {
-  test.each(["1596597629980", "1640273437757"])(
+  test.each(["1664976736980", "1640273437757"])(
     "%p should be inferred as an timestamp",
     (value) => {
       expect(inferType(value)).toEqual({
@@ -187,7 +187,7 @@ describe("timestamps", () => {
     });
   });
 
-  test.each(["1596597839946364285"])("%p should be inferred as an timestamp", (value) => {
+  test.each(["1664976736946364285"])("%p should be inferred as an timestamp", (value) => {
     expect(inferType(value)).toEqual({
       name: "string",
       value,