@inflector/optima 1.0.0 → 1.0.1

package/src/schema.ts

@@ -1,446 +0,0 @@
-import * as z from "zod";
-
-type DefaultConfig = { [K in keyof ColumnConfig]: false };
-// Helper: Sets Key K to true in Config C
-type SetFlag<C extends ColumnConfig, K extends keyof ColumnConfig> = Omit<
-  C,
-  K
-> & { [P in K]: true };
-
-export type Prettify<T> = {
-  [K in keyof T]: T[K];
-} & {};
-
-export type Restrict<K extends keyof ColumnConfig> = {
-  [P in keyof ColumnConfig]: P extends K ? true : false;
-};
-
-// Phantom type brand symbol
-declare const __parentBrand: unique symbol;
-type ParentBrand<Name extends string> = { [__parentBrand]: Name };
-
-// Reference wrapper types for one-to-one and one-to-many relationships
-// Using string literal type discrimination instead of symbols for cross-module compatibility
-export type One<T> = T & { readonly __refKind: "one" };
-export type Many<T> = T & { readonly __refKind: "many" };
-
-// Helper functions for reference syntax
-export const refHelpers = {
-  one: <T>(ref: T): One<T> => ref as One<T>,
-  many: <T>(ref: T): Many<T> => ref as Many<T>,
-};
-
-export type InferColumnType<T> = T extends ColumnBuilder<infer U, any, any>
-  ? U
-  : never;
-
-export type Infer<T extends Record<string, any>> = Prettify<
-  // 1. Handle Required Keys (notnull: true)
-  {
-    [K in keyof T as K extends `__${string}`
-      ? never
-      : T[K] extends ColumnBuilder<any, infer C, any>
-      ? C["notnull"] extends true
-        ? K
-        : never
-      : never]: T[K] extends ColumnBuilder<infer U, any, any> ? U : never;
-  } & // 2. Handle Optional Keys (notnull: false)
-  {
-    [K in keyof T as K extends `__${string}`
-      ? never
-      : T[K] extends ColumnBuilder<any, infer C, any>
-      ? C["notnull"] extends true
-        ? never
-        : K
-      : never]: T[K] extends ColumnBuilder<infer U, any, any>
-      ? U | null
-      : never;
-  }
->;
-export type InferAdd<T extends Record<string, any>> = Prettify<
-  // 1. Handle Required Keys (notnull: true)
-  {
-    [K in keyof T as K extends `__${string}`
-      ? never
-      : T[K] extends ColumnBuilder<any, infer C, any>
-      ? C["notnull"] extends true
-        ? K
-        : never
-      : never]: T[K] extends ColumnBuilder<infer U, any, any> ? U : never;
-  } & // 2. Handle Optional Keys (notnull: false)
-  {
-    [K in keyof T as K extends `__${string}`
-      ? never
-      : T[K] extends ColumnBuilder<any, infer C, any>
-      ? C["notnull"] extends true
-        ? never
-        : K
-      : never]?: T[K] extends ColumnBuilder<infer U, any, any>
-      ? U | null
-      : never;
-  }
->;
-
-export type ColumnConfig = {
-  SQlType: boolean;
-  primaryKey: boolean;
-  notnull: boolean;
-  unique: boolean;
-  default: boolean;
-  defaultNow: boolean;
-  reference: boolean;
-  validate: boolean;
-  transform: boolean;
-  deprecated: boolean;
-  STRUCTType: boolean;
-};
-
-export type ColumnBuilder<
-  Type,
-  Config extends ColumnConfig,
-  RefSchema = never
-> = {
-  [K in keyof ColumnConfig as K extends "STRUCTType"
-    ? never
-    : Config[K] extends true
-    ? never
-    : K]: K extends "SQlType"
-    ? (
-        val: string
-      ) => ColumnBuilder<Type, SetFlag<Config, "SQlType">, RefSchema>
-    : K extends "primaryKey"
-    ? () => ColumnBuilder<Type, SetFlag<Config, "primaryKey">, RefSchema>
-    : K extends "notnull"
-    ? () => ColumnBuilder<Type, SetFlag<Config, "notnull">, RefSchema>
-    : K extends "unique"
-    ? () => ColumnBuilder<Type, SetFlag<Config, "unique">, RefSchema>
-    : K extends "default"
-    ? (
-        val: Type | (() => Type)
-      ) => ColumnBuilder<Type, SetFlag<Config, "default">, RefSchema>
-    : K extends "defaultNow"
-    ? () => ColumnBuilder<Type, SetFlag<Config, "defaultNow">, RefSchema>
-    : K extends "reference"
-    ? <TRef>(
-        ref: (helpers: typeof refHelpers) => TRef
-      ) => ColumnBuilder<Type, SetFlag<Config, "reference">, TRef>
-    : K extends "validate"
-    ? (
-        fn: (val: Type) => boolean
-      ) => ColumnBuilder<Type, SetFlag<Config, "validate">, RefSchema>
-    : K extends "transform"
-    ? (
-        fn: (val: Type) => Type
-      ) => ColumnBuilder<Type, SetFlag<Config, "transform">, RefSchema>
-    : K extends "deprecated"
-    ? () => ColumnBuilder<Type, SetFlag<Config, "deprecated">, RefSchema>
-    : never;
-};
-
-class ColumnImpl<Type, RefSchema = never> {
-  public config: Partial<Record<keyof ColumnConfig, any>> = {};
-
-  constructor(config: Partial<Record<keyof ColumnConfig, any>> = {}) {
-    this.config = config;
-  }
-
-  private next(key: keyof ColumnConfig, value: any = true): any {
-    return new ColumnImpl({ ...this.config, [key]: value });
-  }
-
-  SQlType(val: string) {
-    return this.next("SQlType", val);
-  }
-  primaryKey() {
-    return this.next("primaryKey");
-  }
-  notnull() {
-    return this.next("notnull");
-  }
-  unique() {
-    return this.next("unique");
-  }
-  default(val: Type | (() => Type)) {
-    return this.next("default", val);
-  }
-  defaultNow() {
-    return this.next("defaultNow");
-  }
-  reference<TRef>(c: (helpers: typeof refHelpers) => TRef) {
-    // Execute function with helpers to get the wrapped reference
-    const result = c(refHelpers) as any;
-
-    // Detect if it's a Many wrapper by checking the symbol
-    const isManyRef =
-      result?.[Symbol.for("__refType")] === "many" ||
-      (typeof result === "object" && result !== null && "__refType" in result);
-
-    // Unwrap the actual column reference
-    const actualRef = result;
-
-    let refName = "";
-
-    if (actualRef?.__parent && actualRef?.__fieldName) {
-      refName = `${actualRef.__parent}.${actualRef.__fieldName}`;
-    } else {
-      // Fallback: parse function string
-      const code = c.toString();
-      // Extract the reference from patterns like: one(Users.ID) or many(Users.ID)
-      const match = code.match(/(?:one|many)\s*\(\s*([^)]+)\s*\)/);
-      if (match && match[1]) {
-        const refPart = match[1].trim();
-        if (refPart.includes(".")) {
-          refName = refPart;
-        }
-      }
-    }
-
-    // Check if the TRef type is Many<...>
-    // At runtime we need a different check - look at the function body
-    const codeStr = c.toString();
-    const isMany = codeStr.includes("many(");
-
-    const nextConfig = { ...this.config, reference: { ref: refName, isMany } };
-    return new ColumnImpl(nextConfig);
-  }
-
-  validate(fn: (val: Type) => boolean) {
-    return this.next("validate", fn);
-  }
-  transform(fn: (val: any) => Type) {
-    return this.next("transform", fn);
-  }
-  deprecated() {
-    return this.next("deprecated");
-  }
-  STRUCTType(val: string) {
-    return this.next("STRUCTType", val);
-  }
-}
-
-const Column = <
-  Type,
-  Config extends ColumnConfig = DefaultConfig,
-  RefSchema = never
->(
-  conf?: Partial<Record<keyof ColumnConfig, any>>
-): ColumnBuilder<Type, Config, RefSchema> => {
-  return new ColumnImpl<Type, RefSchema>(conf) as any;
-};
-
-export const Int = () =>
-  Column<number, Restrict<"defaultNow">>().SQlType("INTEGER");
-export const BigInt = () =>
-  Column<bigint, Restrict<"defaultNow">>().SQlType("BIGINT");
-export const Float = () =>
-  Column<number, Restrict<"defaultNow">>().SQlType("FLOAT");
-export const Boolean = () =>
-  Column<boolean, Restrict<"defaultNow" | "primaryKey" | "unique">>().SQlType(
-    "BOOLEAN"
-  );
-export const Text = () =>
-  Column<string, Restrict<"defaultNow">>().SQlType("VARCHAR");
-export const Uuid = () =>
-  Column<string, Restrict<"defaultNow">>().SQlType("VARCHAR");
-export const DateType = () =>
-  Column<Date, Restrict<"default">>().SQlType("DATE");
-export const Timestamp = () =>
-  Column<Date, Restrict<"default">>().SQlType("TIMESTAMP");
-export const Enum = <T extends string | number>(vals: readonly T[]) => {
-  const isString = typeof vals[0] === "string";
-  return Column<T, Restrict<"defaultNow">>()
-    .validate((v) => vals.includes(v))
-    .SQlType(isString ? "VARCHAR" : "INTEGER");
-};
-
-// --- RECURSIVE ZOD PARSER START ---
-export * from "zod";
-
-const zodToDuckDBType = (zodType: z.ZodTypeAny): string => {
-  const def: any = (zodType as any)?._def;
-
-  if (
-    def &&
-    (def.typeName === "ZodOptional" || def.typeName === "ZodNullable")
-  ) {
-    return zodToDuckDBType(def.innerType);
-  }
-
-  if (def && def.typeName === "ZodDefault") {
-    return zodToDuckDBType(def.innerType);
-  }
-
-  if (zodType instanceof z.ZodString) return "VARCHAR";
-  if (zodType instanceof z.ZodNumber) return "INTEGER";
-  if (zodType instanceof z.ZodBoolean) return "BOOLEAN";
-  if (zodType instanceof z.ZodDate) return "TIMESTAMP";
-  if (zodType instanceof z.ZodBigInt) return "BIGINT";
-
-  if ("element" in (def ?? {})) {
-    const innerType = zodToDuckDBType(def.element);
-    return `${innerType}[]`;
-  }
-
-  if ("shape" in (def ?? {})) {
-    const shape: Record<string, z.ZodTypeAny> =
-      typeof def.shape === "function" ? def.shape() : def.shape;
-    const structParts = Object.entries(shape).map(([key, value]) => {
-      const fieldType = zodToDuckDBType(value as z.ZodTypeAny);
-      return `${key} ${fieldType}`;
-    });
-    return `STRUCT(${structParts.join(", ")})`;
-  }
-
-  return "VARCHAR";
-};
-
-export const Json = <T extends z.ZodRawShape>(obj: T) => {
-  const zodObj = z.object(obj);
-  const duckDBStructString = zodToDuckDBType(zodObj);
-
-  const col = Column<
-    z.infer<z.ZodObject<T>>,
-    Restrict<"defaultNow" | "primaryKey" | "unique">
-  >().SQlType("STRUCT");
-
-  return (col as any).STRUCTType(duckDBStructString) as typeof col;
-};
-
-export const Array = <T extends z.ZodTypeAny>(schema: T) => {
-  const innerType = zodToDuckDBType(schema);
-
-  const col = Column<
-    z.infer<T>[],
-    Restrict<"defaultNow" | "primaryKey" | "unique">
-  >().SQlType("LIST");
-
-  return (col as any).STRUCTType(`${innerType}[]`) as typeof col;
-};
-
-// ADD-ONS
-export const Email = () =>
-  Column<string, Restrict<"defaultNow">>()
-    .SQlType("VARCHAR")
-    .validate((v) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(v));
-export const Slug = () =>
-  Column<string, Restrict<"defaultNow">>()
-    .SQlType("VARCHAR")
-    .validate((v) => /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(v));
-export const Color = () =>
-  Column<string, Restrict<"defaultNow">>()
-    .SQlType("VARCHAR")
-    .validate((v) => /^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$/.test(v));
-export const Bytes = () =>
-  Column<Uint8Array, Restrict<"defaultNow" | "primaryKey">>().SQlType("BLOB");
-export const Password = () =>
-  Column<string, Restrict<"defaultNow" | "primaryKey" | "unique">>().SQlType(
-    "VARCHAR"
-  );
-export const GeoPoint = () =>
-  Column<
-    { latitude: number; longitude: number },
-    Restrict<"defaultNow" | "primaryKey">
-  >().SQlType("STRUCT");
-export const GeoArea = () =>
-  Column<
-    {
-      latitude: number;
-      longitude: number;
-      radius: number;
-    },
-    Restrict<"defaultNow" | "primaryKey">
-  >().SQlType("STRUCT");
-
-// ---------------------------------------------------------
-// Column & Table Definitions
-// ---------------------------------------------------------
-
-export const Table = <
-  Name extends string,
-  T extends Record<string, ColumnBuilder<any, any>>
->(
-  name: Name,
-  fields: T
-): T & { __tableName: Name } => {
-  // Runtime Metadata Injection
-  for (const [key, value] of Object.entries(fields)) {
-    Object.assign(value, { __parent: name, __fieldName: key });
-  }
-
-  return { ...fields, __tableName: name } as any;
-};
-
-const GetFieldConfig = (
-  f: ColumnBuilder<any, any>
-): {
-  SQlType: string;
-  primaryKey: boolean;
-  notnull: boolean;
-  unique: boolean;
-  default: boolean;
-  defaultNow: boolean;
-  reference: boolean;
-  STRUCTType?: string;
-} => {
-  return (f as any).config;
-};
-
-export class SQLBuilder {
-  static BuildField(name: string, f: ColumnBuilder<any, any>) {
-    const FieldConfig = GetFieldConfig(f);
-    let sql = `${name} ${FieldConfig.SQlType || "TEXT"}`;
-
-    if (
-      (FieldConfig.SQlType == "STRUCT" || FieldConfig.SQlType == "LIST") &&
-      FieldConfig.STRUCTType
-    ) {
-      sql = `${name} ${FieldConfig.STRUCTType}`;
-    }
-
-    if (FieldConfig.primaryKey) sql += " PRIMARY KEY";
-    if (FieldConfig.notnull) sql += " NOT NULL";
-    if (FieldConfig.unique) sql += " UNIQUE";
-    if (FieldConfig.defaultNow) sql += ` DEFAULT CURRENT_TIMESTAMP`;
-
-    if (
-      FieldConfig.SQlType !== "STRUCT" &&
-      FieldConfig.SQlType !== "LIST" &&
-      FieldConfig.default !== false &&
-      FieldConfig.default !== undefined
-    ) {
-      if (typeof FieldConfig.default !== "function") {
-        sql += ` DEFAULT ${
-          typeof FieldConfig.default === "string"
-            ? `'${FieldConfig.default}'`
-            : JSON.stringify(FieldConfig.default)
-        }`;
-      }
-    }
-
-    if (
-      (FieldConfig.SQlType == "STRUCT" || FieldConfig.SQlType == "LIST") &&
-      FieldConfig.default !== false &&
-      FieldConfig.default !== undefined
-    ) {
-      // Use split/join for compatibility with older JS/TS targets (replaceAll not supported)
-      sql += ` DEFAULT ${JSON.stringify(FieldConfig.default).split('"').join("'")}`;
-    }
-
-    return {
-      sql: sql.trim(),
-      // @ts-ignore
-      ref: FieldConfig.reference,
-    };
-  }
-  static BuildTable(name: string, t: Record<string, any>) {
-    const fieldDefs = Object.entries(t)
-      .filter(([key]) => key !== "__tableName")
-      .map(([fieldName, builder]) => {
-        const Result = this.BuildField(fieldName, builder);
-        return Result.sql;
-      });
-    return `CREATE TABLE IF NOT EXISTS ${name} (\n  ${fieldDefs.join(
-      ",\n  "
-    )}\n);`;
-  }
-}