@rebasepro/schema-inference 0.0.1-canary.09e5ec5

package/src/test_schemas/test_schema.ts

@@ -0,0 +1,34 @@
+import { buildEntityPropertiesFromData } from "../collection_builder";
+
+// import usage from "./usage.json" assert {
+//         type: "json",
+//         integrity: "sha384-ABC123"
+//         };
+import usage from "./pop_products.json" assert {
+    type: "json",
+    integrity: "sha384-ABC123"
+};
+import * as util from "util";
+import { DataType } from "@rebasepro/types";
+
+buildEntityPropertiesFromData(usage, getType)
+    .then((res) => console.log(util.inspect(res, { showHidden: false,
+depth: null,
+colors: true })));
+
+
+function getType(value: any): DataType {
+    if (typeof value === "number")
+        return "number";
+    else if (typeof value === "string")
+        return "string";
+    else if (typeof value === "boolean")
+        return "boolean";
+    else if (Array.isArray(value))
+        return "array";
+    else if (value && "_seconds" in value && "_nanoseconds" in value)
+        return "date";
+    else if (value && "id" in value && "path" in value)
+        return "reference";
+    return "map";
+}

package/src/types.ts

@@ -0,0 +1,43 @@
+import { DataType } from "@rebasepro/types";
+
+export type TypesCount = {
+    number?: number,
+    string?: number,
+    boolean?: number,
+    map?: TypesCountRecord,
+    array?: TypesCount,
+    date?: number,
+    geopoint?: number,
+    reference?: number,
+    relation?: number,
+};
+
+export type TypesCountRecord<K extends keyof DataType = any> = {
+    [P in K]: TypesCount
+};
+
+export type ValuesCountEntry = {
+    values: any[];
+    valuesCount: Map<any, number>;
+    mapValues?: ValuesCountRecord;
+};
+
+export type ValuesCountRecord = Record<string, ValuesCountEntry>;
+
+export type InferencePropertyBuilderProps = {
+
+    /**
+     * Name of the property
+     */
+    name: string;
+
+    /**
+     * Total documents this props are built from
+     */
+    totalDocsCount: number;
+
+    /**
+     * How many times does each value show up
+     */
+    valuesResult?: ValuesCountEntry;
+};

package/src/util.ts

@@ -0,0 +1,44 @@
+import { EnumValueConfig, EnumValues } from "@rebasepro/types";
+import { unslugify } from "@rebasepro/utils";
+
+// Canonical utility functions — single source of truth in @rebasepro/utils
+export { unslugify, prettifyIdentifier, isObject, isPlainObject, mergeDeep } from "@rebasepro/utils";
+
+/**
+ * Extract enum values from a list of sample values.
+ * This is schema-inference-specific logic (not a general utility).
+ */
+export function extractEnumFromValues(values: unknown[]) {
+    if (!Array.isArray(values)) {
+        return [];
+    }
+    const enumValues = values
+        .map((value) => {
+            if (typeof value === "string") {
+                return ({
+                    id: value,
+                    label: unslugify(value)
+                });
+            } else
+                return null;
+        }).filter(Boolean) as Array<{ id: string, label: string }>;
+    enumValues.sort((a, b) => a.label.localeCompare(b.label));
+    return enumValues;
+}
+
+export function resolveEnumValues(input: EnumValues): EnumValueConfig[] | undefined {
+    // Check Array.isArray first since typeof [] === "object" is true in JavaScript
+    if (Array.isArray(input)) {
+        return input as EnumValueConfig[];
+    } else if (typeof input === "object" && input !== null) {
+        return Object.entries(input).map(([id, value]) =>
+        (typeof value === "string"
+            ? {
+                id,
+                label: value
+            }
+            : value));
+    } else {
+        return undefined;
+    }
+}