@supabase/postgrest-typegen 0.3.1 → 0.5.0

package/dist/generation/swift.js

@@ -1,358 +0,0 @@
-import { compareStrings } from "../collation.js";
-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(", ")}`;
-}
-/**
- * Serializes a database-provided value as a Swift string literal. Backslashes
- * would otherwise start escape or interpolation sequences (`\(`), double
- * quotes would terminate the literal early, and line breaks or control
- * characters are not allowed in single-line literals, so all of them are
- * escaped per Swift's string literal grammar. U+2028 and U+2029 are legal in
- * Swift literals but are escaped anyway because other tooling mishandles
- * them. Swift unescapes at compile time, so raw values round-trip unchanged.
- */
-function swiftStringLiteral(value) {
-    let escaped = "";
-    for (const character of value) {
-        switch (character) {
-            case "\\":
-                escaped += "\\\\";
-                break;
-            case '"':
-                escaped += '\\"';
-                break;
-            case "\t":
-                escaped += "\\t";
-                break;
-            case "\n":
-                escaped += "\\n";
-                break;
-            case "\r":
-                escaped += "\\r";
-                break;
-            default: {
-                const codePoint = character.codePointAt(0);
-                escaped +=
-                    codePoint < 0x20 ||
-                        codePoint === 0x7f ||
-                        codePoint === 0x2028 ||
-                        codePoint === 0x2029
-                        ? `\\u{${codePoint.toString(16)}}`
-                        : character;
-            }
-        }
-    }
-    return `"${escaped}"`;
-}
-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} = ${swiftStringLiteral(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,
-        [],
-    ]));
-    for (const column of columns) {
-        columnsByTableId[column.table_id]?.push(column);
-    }
-    let output = [
-        "import Foundation",
-        "import Supabase",
-        "",
-        ...schemas.flatMap((schema) => {
-            const schemaTables = [...tables, ...foreignTables]
-                .filter((table) => table.schema === schema.name)
-                .sort(({ name: a }, { name: b }) => compareStrings(a, b));
-            const schemaViews = [...views, ...materializedViews]
-                .filter((table) => table.schema === schema.name)
-                .sort(({ name: a }, { name: b }) => compareStrings(a, 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")}\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";
-        // `void` and `record` are pseudo-types: Postgres rejects them as a column or
-        // composite attribute type ("column has pseudo-type void"), and this
-        // generator only renders columns and attributes, never functions. So these
-        // two arms are unreachable today and deliberately untested. They are kept
-        // because they are the mappings to use if Swift ever emits functions, which
-        // is where these types do appear.
-    }
-    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.charAt(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/src/generation/constants.ts

@@ -1,11 +0,0 @@
-/**
- * Type-generation constants ported verbatim from
- * `postgres-meta/src/server/constants.ts`. Only the typegen-relevant values
- * live here; server/runtime constants stay in postgres-meta.
- *
- * Consumed by the TypeScript generator's function-argument handling.
- */
-
-// json/jsonb/text types
-export const VALID_UNNAMED_FUNCTION_ARG_TYPES = new Set([114, 3802, 25]);
-export const VALID_FUNCTION_ARGS_MODE = new Set(["in", "inout", "variadic"]);