@rebasepro/schema-inference 0.0.1-canary.4d4fb3e

package/src/test_schemas/test_schema.ts

@@ -0,0 +1,32 @@
+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,116 @@
+import { EnumValueConfig, EnumValues } from "@rebasepro/types";
+
+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 prettifyIdentifier(input: string) {
+    if (!input) return "";
+
+    let text = input;
+
+    // 1. Handle camelCase and Acronyms
+    // Group 1 ($1 $2): Lowercase followed by Uppercase (e.g., imageURL -> image URL)
+    // Group 2 ($3 $4): Uppercase followed by Uppercase+lowercase (e.g., XMLParser -> XML Parser)
+    text = text.replace(/([a-z])([A-Z])|([A-Z])([A-Z][a-z])/g, "$1$3 $2$4");
+
+    // 2. Replace hyphens/underscores with spaces
+    text = text.replace(/[_-]+/g, " ");
+
+    // 3. Capitalize first letter of each word (Title Case)
+    const s = text
+        .trim()
+        .replace(/\b\w/g, (char) => char.toUpperCase());
+    console.log("Prettified identifier:", {
+        input,
+        s
+    });
+    return s;
+}
+
+export function unslugify(slug?: string): string {
+    if (!slug) return "";
+    if (slug.includes("-") || slug.includes("_") || !slug.includes(" ")) {
+        const result = slug.replace(/[-_]/g, " ");
+        return result.replace(/\w\S*/g, function (txt) {
+            return txt.charAt(0).toUpperCase() + txt.substring(1);
+        }).trim();
+    } else {
+        return slug.trim();
+    }
+}
+
+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;
+    }
+}
+
+export function mergeDeep<T extends Record<any, any>, U extends Record<any, any>>(target: T, source: U, ignoreUndefined: boolean = false): T & U {
+    const targetIsObject = isObject(target);
+    const output = targetIsObject ? { ...target } : target;
+    if (targetIsObject && isObject(source)) {
+        Object.keys(source).forEach(key => {
+            const sourceElement = source[key];
+            // Skip undefined values when ignoreUndefined is true
+            if (ignoreUndefined && sourceElement === undefined) {
+                return;
+            }
+            if (sourceElement instanceof Date) {
+                // Assign a new Date instance with the same time value
+                Object.assign(output, { [key]: new Date(sourceElement.getTime()) });
+            } else if (isPlainObject(sourceElement)) {
+                // Only recursively merge plain objects, not class instances
+                if (!(key in target))
+                    Object.assign(output, { [key]: sourceElement });
+                else if (isPlainObject((target as Record<string, unknown>)[key]))
+                    (output as Record<string, unknown>)[key] = mergeDeep((target as Record<string, unknown>)[key] as Record<string, unknown>, sourceElement);
+                else
+                    Object.assign(output, { [key]: sourceElement });
+            } else if (isObject(sourceElement)) {
+                // For class instances (EntityReference, GeoPoint, etc.), assign directly to preserve prototype
+                Object.assign(output, { [key]: sourceElement });
+            } else {
+                Object.assign(output, { [key]: sourceElement });
+            }
+        });
+    }
+    return output as T;
+}
+
+export function isObject(item: any) {
+    return item && typeof item === "object" && !Array.isArray(item);
+}
+
+export function isPlainObject(obj: any) {
+    if (typeof obj !== "object" || obj === null || Array.isArray(obj)) {
+        return false;
+    }
+    return Object.getPrototypeOf(obj) === Object.prototype;
+}
+