@supabase/postgrest-typegen 0.0.1

package/dist/generation/python.js

@@ -0,0 +1,339 @@
+/**
+ * Emits tables/views/materialized views in `GeneratorMetadata` order. Pass
+ * input pre-sorted with `sortGeneratorMetadata` for deterministic output.
+ */
+export const generatePython = ({ schemas, tables, views, materializedViews, columns, types, }) => {
+    const ctx = new PythonContext(types, columns, schemas);
+    // Used for efficient lookup of types by schema name
+    const schemasNames = new Set(schemas.map((schema) => schema.name));
+    const py_tables = tables.flatMap((table) => {
+        const py_class_and_methods = ctx.tableToClass(table);
+        return py_class_and_methods;
+    });
+    const composite_types = types
+        // We always include system schemas, so we need to filter out types that are not in the included schemas
+        .filter((type) => type.attributes.length > 0 && schemasNames.has(type.schema))
+        .map((type) => ctx.typeToClass(type));
+    const py_views = views.map((view) => ctx.viewToClass(view));
+    const py_matviews = materializedViews.map((matview) => ctx.matViewToClass(matview));
+    let output = `
+from __future__ import annotations
+
+import datetime
+import uuid
+from typing import (
+    Annotated,
+    Any,
+    List,
+    Literal,
+    NotRequired,
+    Optional,
+    TypeAlias,
+    TypedDict,
+)
+
+from pydantic import BaseModel, Field, Json
+
+${concatLines(Object.values(ctx.user_enums))}
+
+${concatLines(py_tables)}
+
+${concatLines(py_views)}
+
+${concatLines(py_matviews)}
+
+${concatLines(composite_types)}
+
+`.trim();
+    return output;
+};
+class PythonContext {
+    types;
+    user_enums;
+    columns;
+    schemas;
+    constructor(types, columns, schemas) {
+        this.schemas = Object.fromEntries(schemas.map((schema) => [schema.name, schema]));
+        this.types = Object.fromEntries(types.map((type) => [type.name, type]));
+        this.columns = columns.reduce((acc, curr) => {
+            acc[curr.table_id] ??= [];
+            acc[curr.table_id].push(curr);
+            return acc;
+        }, {});
+        this.user_enums = Object.fromEntries(types
+            .filter((type) => type.enums.length > 0)
+            .map((type) => [type.name, new PythonEnum(type)]));
+    }
+    resolveTypeName(name) {
+        if (name in this.user_enums) {
+            return this.user_enums[name].name;
+        }
+        if (name in PY_TYPE_MAP) {
+            return PY_TYPE_MAP[name];
+        }
+        if (name in this.types) {
+            const type = this.types[name];
+            const schema = type.schema;
+            return `${formatForPyClassName(schema)}${formatForPyClassName(type.name)}`;
+        }
+        return "Any";
+    }
+    parsePgType(pg_type) {
+        if (pg_type.startsWith("_")) {
+            const inner_str = pg_type.slice(1);
+            const inner = this.parsePgType(inner_str);
+            return new PythonListType(inner);
+        }
+        else {
+            const type_name = this.resolveTypeName(pg_type);
+            return new PythonSimpleType(type_name);
+        }
+    }
+    typeToClass(type) {
+        const types = Object.values(this.types);
+        const attributes = type.attributes.map((attribute) => {
+            const type = types.find((type) => type.id === attribute.type_id);
+            return {
+                ...attribute,
+                type,
+            };
+        });
+        const attributeEntries = attributes.map((attribute) => {
+            const type = this.parsePgType(attribute.type.name);
+            return new PythonBaseModelAttr(attribute.name, type, false);
+        });
+        const schema = this.schemas[type.schema];
+        return new PythonBaseModel(type.name, schema, attributeEntries);
+    }
+    columnsToClassAttrs(table_id) {
+        const attrs = this.columns[table_id] ?? [];
+        return attrs.map((col) => {
+            const type = this.parsePgType(col.format);
+            return new PythonBaseModelAttr(col.name, type, col.is_nullable);
+        });
+    }
+    columnsToDictAttrs(table_id, not_required) {
+        const attrs = this.columns[table_id] ?? [];
+        return attrs.map((col) => {
+            const type = this.parsePgType(col.format);
+            return new PythonTypedDictAttr(col.name, type, col.is_nullable, not_required ||
+                col.is_nullable ||
+                col.is_identity ||
+                col.default_value !== null);
+        });
+    }
+    tableToClass(table) {
+        const schema = this.schemas[table.schema];
+        const select = new PythonBaseModel(table.name, schema, this.columnsToClassAttrs(table.id));
+        const insert = new PythonTypedDict(table.name, "Insert", schema, this.columnsToDictAttrs(table.id, false));
+        const update = new PythonTypedDict(table.name, "Update", schema, this.columnsToDictAttrs(table.id, true));
+        return [select, insert, update];
+    }
+    viewToClass(view) {
+        const attributes = this.columnsToClassAttrs(view.id);
+        return new PythonBaseModel(view.name, this.schemas[view.schema], attributes);
+    }
+    matViewToClass(matview) {
+        const attributes = this.columnsToClassAttrs(matview.id);
+        return new PythonBaseModel(matview.name, this.schemas[matview.schema], attributes);
+    }
+}
+class PythonEnum {
+    name;
+    variants;
+    constructor(type) {
+        this.name = `${formatForPyClassName(type.schema)}${formatForPyClassName(type.name)}`;
+        this.variants = type.enums;
+    }
+    serialize() {
+        const variants = this.variants.map((item) => `"${item}"`).join(", ");
+        return `${this.name}: TypeAlias = Literal[${variants}]`;
+    }
+}
+class PythonSimpleType {
+    name;
+    constructor(name) {
+        this.name = name;
+    }
+    serialize() {
+        return this.name;
+    }
+}
+class PythonListType {
+    inner;
+    constructor(inner) {
+        this.inner = inner;
+    }
+    serialize() {
+        return `List[${this.inner.serialize()}]`;
+    }
+}
+class PythonBaseModelAttr {
+    name;
+    pg_name;
+    py_type;
+    nullable;
+    constructor(name, py_type, nullable) {
+        this.name = formatForPyAttributeName(name);
+        this.pg_name = name;
+        this.py_type = py_type;
+        this.nullable = nullable;
+    }
+    serialize() {
+        const py_type = this.nullable
+            ? `Optional[${this.py_type.serialize()}]`
+            : this.py_type.serialize();
+        return `    ${this.name}: ${py_type} = Field(alias="${this.pg_name}")`;
+    }
+}
+class PythonBaseModel {
+    name;
+    table_name;
+    schema;
+    class_attributes;
+    constructor(name, schema, class_attributes) {
+        this.schema = schema;
+        this.class_attributes = class_attributes;
+        this.table_name = name;
+        this.name = `${formatForPyClassName(schema.name)}${formatForPyClassName(name)}`;
+    }
+    serialize() {
+        const attributes = this.class_attributes.length > 0
+            ? this.class_attributes.map((attr) => attr.serialize()).join("\n")
+            : "    pass";
+        return `class ${this.name}(BaseModel):\n${attributes}`;
+    }
+}
+class PythonTypedDictAttr {
+    name;
+    pg_name;
+    py_type;
+    nullable;
+    not_required;
+    constructor(name, py_type, nullable, required) {
+        this.name = formatForPyAttributeName(name);
+        this.pg_name = name;
+        this.py_type = py_type;
+        this.nullable = nullable;
+        this.not_required = required;
+    }
+    serialize() {
+        const py_type = this.nullable
+            ? `Optional[${this.py_type.serialize()}]`
+            : this.py_type.serialize();
+        const annotation = `Annotated[${py_type}, Field(alias="${this.pg_name}")]`;
+        const rhs = this.not_required ? `NotRequired[${annotation}]` : annotation;
+        return `    ${this.name}: ${rhs}`;
+    }
+}
+class PythonTypedDict {
+    name;
+    table_name;
+    parent_class;
+    schema;
+    dict_attributes;
+    operation;
+    constructor(name, operation, schema, dict_attributes, parent_class = "BaseModel") {
+        this.schema = schema;
+        this.dict_attributes = dict_attributes;
+        this.table_name = name;
+        this.name = `${formatForPyClassName(schema.name)}${formatForPyClassName(name)}`;
+        this.parent_class = parent_class;
+        this.operation = operation;
+    }
+    serialize() {
+        const attributes = this.dict_attributes.length > 0
+            ? this.dict_attributes.map((attr) => attr.serialize()).join("\n")
+            : "    pass";
+        return `class ${this.name}${this.operation}(TypedDict):\n${attributes}`;
+    }
+}
+function concatLines(items) {
+    return items.map((item) => item.serialize()).join("\n\n");
+}
+const PY_TYPE_MAP = {
+    // Bool
+    bool: "bool",
+    // Numbers
+    int2: "int",
+    int4: "int",
+    int8: "int",
+    float4: "float",
+    float8: "float",
+    numeric: "float",
+    // Strings
+    bytea: "bytes",
+    bpchar: "str",
+    varchar: "str",
+    string: "str",
+    date: "datetime.date",
+    text: "str",
+    citext: "str",
+    time: "datetime.time",
+    timetz: "datetime.time",
+    timestamp: "datetime.datetime",
+    timestamptz: "datetime.datetime",
+    uuid: "uuid.UUID",
+    vector: "list[Any]",
+    interval: "str",
+    // JSON
+    json: "Json[Any]",
+    jsonb: "Json[Any]",
+    // Range types (can be adjusted to more complex types if needed)
+    int4range: "str",
+    int4multirange: "str",
+    int8range: "str",
+    int8multirange: "str",
+    numrange: "str",
+    nummultirange: "str",
+    tsrange: "str",
+    tsmultirange: "str",
+    tstzrange: "str",
+    tstzmultirange: "str",
+    daterange: "str",
+    datemultirange: "str",
+    // Miscellaneous types
+    void: "None",
+    record: "dict[str, Any]",
+};
+/**
+ * Converts a Postgres name to PascalCase.
+ *
+ * @example
+ * ```ts
+ * formatForPyTypeName('pokedex') // Pokedex
+ * formatForPyTypeName('pokemon_center') // PokemonCenter
+ * formatForPyTypeName('victory-road') // VictoryRoad
+ * formatForPyTypeName('pokemon league') // PokemonLeague
+ * ```
+ */
+function formatForPyClassName(name) {
+    return name
+        .split(/[^a-zA-Z0-9]/)
+        .map((word) => {
+        if (word) {
+            return `${word[0].toUpperCase()}${word.slice(1)}`;
+        }
+        else {
+            return "";
+        }
+    })
+        .join("");
+}
+/**
+ * Converts a Postgres name to snake_case.
+ *
+ * @example
+ * ```ts
+ * formatForPyTypeName('Pokedex') // pokedex
+ * formatForPyTypeName('PokemonCenter') // pokemon_enter
+ * formatForPyTypeName('victory-road') // victory_road
+ * formatForPyTypeName('pokemon league') // pokemon_league
+ * ```
+ */
+function formatForPyAttributeName(name) {
+    return name
+        .split(/[^a-zA-Z0-9]+/) // Split on non-alphanumeric characters (like spaces, dashes, etc.)
+        .map((word) => word.toLowerCase()) // Convert each word to lowercase
+        .join("_"); // Join with underscores
+}

package/dist/generation/swift.d.ts

@@ -0,0 +1,11 @@
+import type { GeneratorMetadata } from "../types.ts";
+export type AccessControl = "internal" | "public" | "private" | "package";
+export interface GenerateSwiftOptions {
+    /** Swift access-control level applied to generated declarations. Default `'internal'`. */
+    accessControl?: AccessControl;
+}
+/**
+ * Emits tables/views/materialized views in `GeneratorMetadata` order. Pass
+ * input pre-sorted with `sortGeneratorMetadata` for deterministic output.
+ */
+export declare const generateSwift: (metadata: GeneratorMetadata, opts?: GenerateSwiftOptions) => string;

package/dist/generation/swift.js

@@ -0,0 +1,309 @@
+function formatForSwiftSchemaName(schema) {
+    return `${formatForSwiftTypeName(schema)}Schema`;
+}
+function pgEnumToSwiftEnum(pgEnum) {
+    return {
+        formattedEnumName: formatForSwiftTypeName(pgEnum.name),
+        protocolConformances: ["String", "Codable", "Hashable", "Sendable"],
+        cases: pgEnum.enums.map((case_) => {
+            return {
+                formattedName: formatForSwiftPropertyName(case_),
+                rawValue: case_,
+            };
+        }),
+    };
+}
+function pgTypeToSwiftStruct(table, columns, operation, { types, views, tables, }) {
+    const columnEntries = columns?.map((column) => {
+        let nullable;
+        if (operation === "Insert") {
+            nullable =
+                column.is_nullable ||
+                    column.is_identity ||
+                    column.is_generated ||
+                    !!column.default_value;
+        }
+        else if (operation === "Update") {
+            nullable = true;
+        }
+        else {
+            nullable = column.is_nullable;
+        }
+        return {
+            rawName: column.name,
+            formattedAttributeName: formatForSwiftPropertyName(column.name),
+            formattedType: pgTypeToSwiftType(column.format, nullable, {
+                types,
+                views,
+                tables,
+            }),
+            isIdentity: column.is_identity,
+        };
+    }) ?? [];
+    return {
+        formattedStructName: `${formatForSwiftTypeName(table.name)}${operation}`,
+        attributes: columnEntries,
+        protocolConformances: ["Codable", "Hashable", "Sendable"],
+        codingKeysEnum: generateCodingKeysEnumFromAttributes(columnEntries),
+    };
+}
+function generateCodingKeysEnumFromAttributes(attributes) {
+    return attributes.length > 0
+        ? {
+            formattedEnumName: "CodingKeys",
+            protocolConformances: ["String", "CodingKey"],
+            cases: attributes.map((attribute) => {
+                return {
+                    formattedName: attribute.formattedAttributeName,
+                    rawValue: attribute.rawName,
+                };
+            }),
+        }
+        : undefined;
+}
+function pgCompositeTypeToSwiftStruct(type, { types, views, tables, }) {
+    const typeWithRetrievedAttributes = {
+        ...type,
+        attributes: type.attributes.map((attribute) => {
+            const type = types.find((type) => type.id === attribute.type_id);
+            return {
+                ...attribute,
+                type,
+            };
+        }),
+    };
+    const attributeEntries = typeWithRetrievedAttributes.attributes.map((attribute) => {
+        return {
+            formattedAttributeName: formatForSwiftTypeName(attribute.name),
+            formattedType: pgTypeToSwiftType(attribute.type.format, false, {
+                types,
+                views,
+                tables,
+            }),
+            rawName: attribute.name,
+            isIdentity: false,
+        };
+    });
+    return {
+        formattedStructName: formatForSwiftTypeName(type.name),
+        attributes: attributeEntries,
+        protocolConformances: ["Codable", "Hashable", "Sendable"],
+        codingKeysEnum: generateCodingKeysEnumFromAttributes(attributeEntries),
+    };
+}
+function generateProtocolConformances(protocols) {
+    return protocols.length === 0 ? "" : `: ${protocols.join(", ")}`;
+}
+function generateEnum(enum_, { accessControl, level }) {
+    return [
+        `${ident(level)}${accessControl} enum ${enum_.formattedEnumName}${generateProtocolConformances(enum_.protocolConformances)} {`,
+        ...enum_.cases.map((case_) => `${ident(level + 1)}case ${case_.formattedName} = "${case_.rawValue}"`),
+        `${ident(level)}}`,
+    ];
+}
+function generateStruct(struct, { accessControl, level }) {
+    const identity = struct.attributes.find((column) => column.isIdentity);
+    let protocolConformances = struct.protocolConformances;
+    if (identity) {
+        protocolConformances.push("Identifiable");
+    }
+    let output = [
+        `${ident(level)}${accessControl} struct ${struct.formattedStructName}${generateProtocolConformances(struct.protocolConformances)} {`,
+    ];
+    if (identity && identity.formattedAttributeName !== "id") {
+        output.push(`${ident(level + 1)}${accessControl} var id: ${identity.formattedType} { ${identity.formattedAttributeName} }`);
+    }
+    output.push(...struct.attributes.map((attribute) => `${ident(level + 1)}${accessControl} let ${attribute.formattedAttributeName}: ${attribute.formattedType}`));
+    if (struct.codingKeysEnum) {
+        output.push(...generateEnum(struct.codingKeysEnum, {
+            accessControl,
+            level: level + 1,
+        }));
+    }
+    output.push(`${ident(level)}}`);
+    return output;
+}
+/**
+ * Emits tables/views/materialized views in `GeneratorMetadata` order. Pass
+ * input pre-sorted with `sortGeneratorMetadata` for deterministic output.
+ */
+export const generateSwift = (metadata, opts = {}) => {
+    const { schemas, tables, foreignTables, views, materializedViews, columns, types, } = metadata;
+    const { accessControl = "internal" } = opts;
+    const columnsByTableId = Object.fromEntries([...tables, ...foreignTables, ...views, ...materializedViews].map((t) => [
+        t.id,
+        [],
+    ]));
+    columns
+        .filter((c) => c.table_id in columnsByTableId)
+        .forEach((c) => columnsByTableId[c.table_id].push(c));
+    let output = [
+        "import Foundation",
+        "import Supabase",
+        "",
+        ...schemas.flatMap((schema) => {
+            const schemaTables = [...tables, ...foreignTables]
+                .filter((table) => table.schema === schema.name)
+                .sort(({ name: a }, { name: b }) => a.localeCompare(b));
+            const schemaViews = [...views, ...materializedViews]
+                .filter((table) => table.schema === schema.name)
+                .sort(({ name: a }, { name: b }) => a.localeCompare(b));
+            const schemaEnums = types.filter((type) => type.schema === schema.name && type.enums.length > 0);
+            const schemaCompositeTypes = types.filter((type) => type.schema === schema.name && type.attributes.length > 0);
+            return [
+                `${accessControl} enum ${formatForSwiftSchemaName(schema.name)} {`,
+                ...schemaEnums.flatMap((enum_) => generateEnum(pgEnumToSwiftEnum(enum_), { accessControl, level: 1 })),
+                ...schemaTables.flatMap((table) => ["Select", "Insert", "Update"]
+                    .map((operation) => pgTypeToSwiftStruct(table, columnsByTableId[table.id], operation, {
+                    types,
+                    views,
+                    tables,
+                }))
+                    .flatMap((struct) => generateStruct(struct, { accessControl, level: 1 }))),
+                ...schemaViews.flatMap((view) => generateStruct(pgTypeToSwiftStruct(view, columnsByTableId[view.id], "Select", {
+                    types,
+                    views,
+                    tables,
+                }), { accessControl, level: 1 })),
+                ...schemaCompositeTypes.flatMap((type) => generateStruct(pgCompositeTypeToSwiftStruct(type, { types, views, tables }), {
+                    accessControl,
+                    level: 1,
+                })),
+                "}",
+            ];
+        }),
+    ];
+    return output.join("\n");
+};
+// TODO: Make this more robust. Currently doesn't handle range types - returns them as string.
+const pgTypeToSwiftType = (pgType, nullable, { types, views, tables, }) => {
+    let swiftType;
+    if (pgType === "bool") {
+        swiftType = "Bool";
+    }
+    else if (pgType === "int2") {
+        swiftType = "Int16";
+    }
+    else if (pgType === "int4") {
+        swiftType = "Int32";
+    }
+    else if (pgType === "int8") {
+        swiftType = "Int64";
+    }
+    else if (pgType === "float4") {
+        swiftType = "Float";
+    }
+    else if (pgType === "float8") {
+        swiftType = "Double";
+    }
+    else if (["numeric", "decimal"].includes(pgType)) {
+        swiftType = "Decimal";
+    }
+    else if (pgType === "uuid") {
+        swiftType = "UUID";
+    }
+    else if ([
+        "bytea",
+        "bpchar",
+        "varchar",
+        "date",
+        "text",
+        "citext",
+        "time",
+        "timetz",
+        "timestamp",
+        "timestamptz",
+        "interval",
+        "vector",
+    ].includes(pgType)) {
+        swiftType = "String";
+    }
+    else if (["json", "jsonb"].includes(pgType)) {
+        swiftType = "AnyJSON";
+    }
+    else if (pgType === "void") {
+        swiftType = "Void";
+    }
+    else if (pgType === "record") {
+        swiftType = "JSONObject";
+    }
+    else if (pgType.startsWith("_")) {
+        swiftType = `[${pgTypeToSwiftType(pgType.substring(1), false, { types, views, tables })}]`;
+    }
+    else {
+        const enumType = types.find((type) => type.name === pgType && type.enums.length > 0);
+        const compositeTypes = [...types, ...views, ...tables].find((type) => type.name === pgType);
+        if (enumType) {
+            swiftType = `${formatForSwiftTypeName(enumType.name)}`;
+        }
+        else if (compositeTypes) {
+            // Append a `Select` to the composite type, as that is how is named in the generated struct.
+            swiftType = `${formatForSwiftTypeName(compositeTypes.name)}Select`;
+        }
+        else {
+            swiftType = "AnyJSON";
+        }
+    }
+    return `${swiftType}${nullable ? "?" : ""}`;
+};
+function ident(level, options = { width: 2 }) {
+    return " ".repeat(level * options.width);
+}
+/**
+ * Converts a Postgres name to PascalCase.
+ *
+ * @example
+ * ```ts
+ * formatForSwiftTypeName('pokedex') // Pokedex
+ * formatForSwiftTypeName('pokemon_center') // PokemonCenter
+ * formatForSwiftTypeName('victory-road') // VictoryRoad
+ * formatForSwiftTypeName('pokemon league') // PokemonLeague
+ * formatForSwiftTypeName('_key_id_context') // _KeyIdContext
+ * ```
+ */
+function formatForSwiftTypeName(name) {
+    // Preserve the initial underscore if it exists
+    let prefix = "";
+    if (name.startsWith("_")) {
+        prefix = "_";
+        name = name.slice(1); // Remove the initial underscore for processing
+    }
+    return (prefix +
+        name
+            .split(/[^a-zA-Z0-9]+/)
+            .map((word) => {
+            if (word) {
+                return `${word[0].toUpperCase()}${word.slice(1)}`;
+            }
+            else {
+                return "";
+            }
+        })
+            .join(""));
+}
+const SWIFT_KEYWORDS = ["in", "default", "case"];
+/**
+ * Converts a Postgres name to pascalCase.
+ *
+ * @example
+ * ```ts
+ * formatForSwiftTypeName('pokedex') // pokedex
+ * formatForSwiftTypeName('pokemon_center') // pokemonCenter
+ * formatForSwiftTypeName('victory-road') // victoryRoad
+ * formatForSwiftTypeName('pokemon league') // pokemonLeague
+ * ```
+ */
+function formatForSwiftPropertyName(name) {
+    const propertyName = name
+        .split(/[^a-zA-Z0-9]/)
+        .map((word, index) => {
+        const lowerWord = word.toLowerCase();
+        return index !== 0
+            ? lowerWord.charAt(0).toUpperCase() + lowerWord.slice(1)
+            : lowerWord;
+    })
+        .join("");
+    return SWIFT_KEYWORDS.includes(propertyName)
+        ? `\`${propertyName}\``
+        : propertyName;
+}

package/dist/generation/typescript.d.ts

@@ -0,0 +1,32 @@
+import type { GeneratorMetadata, PostgresSchema, PostgresTable, PostgresType, PostgresView } from "../types.ts";
+export interface GenerateTypescriptOptions {
+    /**
+     * Emit `isOneToOne` on each relationship entry. Mirrors postgres-meta's
+     * `detect_one_to_one_relationships` query flag. Default `false`.
+     */
+    detectOneToOneRelationships?: boolean;
+    /**
+     * When set, emit `__InternalSupabase.PostgrestVersion` so `createClient`
+     * can be instantiated with the right options automatically.
+     */
+    postgrestVersion?: string;
+    /**
+     * Schema treated as the default for the generated `Tables`/`Enums`/etc.
+     * helper types. Replaces postgres-meta's `GENERATE_TYPES_DEFAULT_SCHEMA`
+     * env read. Default `'public'`.
+     */
+    defaultSchema?: string;
+}
+/**
+ * Does not re-sort collections; pass input pre-sorted with
+ * `sortGeneratorMetadata` first. Still merge-sorts tables+foreign tables and
+ * views+materialized views per schema, since that cross-collection grouping
+ * can't be expressed by the single-collection `sortGeneratorMetadata` pass.
+ */
+export declare const generateTypescript: (metadata: GeneratorMetadata, opts?: GenerateTypescriptOptions) => Promise<string>;
+export declare const pgTypeToTsType: (schema: PostgresSchema, pgType: string, { types, schemas, tables, views, }: {
+    types: PostgresType[];
+    schemas: PostgresSchema[];
+    tables: PostgresTable[];
+    views: PostgresView[];
+}, typeSchema?: string) => string;