@voyantjs/db 0.1.0

package/dist/schema/ref/places.d.ts

@@ -0,0 +1,532 @@
+/**
+ * Reference Places Table
+ *
+ * Master table for all location/place data used across the platform.
+ * Stores Google Places data permanently to reduce API costs and enable
+ * offline access to location information.
+ *
+ * Key benefits:
+ * - Single source of truth for places (no duplicate API calls)
+ * - Multi-language translations stored as JSONB
+ * - Canonical coordinates for map rendering without API calls
+ * - Usage tracking for analytics and cache warming
+ */
+import { z } from "zod";
+/**
+ * Translation structure for localized place names and addresses
+ */
+export interface PlaceTranslation {
+    name?: string;
+    address?: string;
+    formattedAddress?: string;
+}
+/**
+ * Viewport bounds for map rendering
+ */
+export interface PlaceViewport {
+    northeast: {
+        lat: number;
+        lng: number;
+    };
+    southwest: {
+        lat: number;
+        lng: number;
+    };
+}
+/**
+ * Place category derived from Google place types
+ */
+export type PlaceCategory = "airport" | "city" | "country" | "hotel" | "restaurant" | "attraction" | "transport_hub" | "port" | "address" | "other";
+export declare const refPlacesTable: Omit<import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "places";
+    schema: "ref";
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "places";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        googlePlaceId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "google_place_id";
+            tableName: "places";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        name: import("drizzle-orm/pg-core").PgColumn<{
+            name: "name";
+            tableName: "places";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        translations: import("drizzle-orm/pg-core").PgColumn<{
+            name: "translations";
+            tableName: "places";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: Record<string, PlaceTranslation>;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: Record<string, PlaceTranslation>;
+        }>;
+        countryCode: import("drizzle-orm/pg-core").PgColumn<{
+            name: "country_code";
+            tableName: "places";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        state: import("drizzle-orm/pg-core").PgColumn<{
+            name: "state";
+            tableName: "places";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        city: import("drizzle-orm/pg-core").PgColumn<{
+            name: "city";
+            tableName: "places";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        postalCode: import("drizzle-orm/pg-core").PgColumn<{
+            name: "postal_code";
+            tableName: "places";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        streetAddress: import("drizzle-orm/pg-core").PgColumn<{
+            name: "street_address";
+            tableName: "places";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        latitude: import("drizzle-orm/pg-core").PgColumn<{
+            name: "latitude";
+            tableName: "places";
+            dataType: "number";
+            columnType: "PgDoublePrecision";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        longitude: import("drizzle-orm/pg-core").PgColumn<{
+            name: "longitude";
+            tableName: "places";
+            dataType: "number";
+            columnType: "PgDoublePrecision";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        types: import("drizzle-orm/pg-core").PgColumn<{
+            name: "types";
+            tableName: "places";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: string[];
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: string[];
+        }>;
+        category: import("drizzle-orm/pg-core").PgColumn<{
+            name: "category";
+            tableName: "places";
+            dataType: "string";
+            columnType: "PgText";
+            data: PlaceCategory;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: PlaceCategory;
+        }>;
+        timezone: import("drizzle-orm/pg-core").PgColumn<{
+            name: "timezone";
+            tableName: "places";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        viewport: import("drizzle-orm/pg-core").PgColumn<{
+            name: "viewport";
+            tableName: "places";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: PlaceViewport;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: PlaceViewport;
+        }>;
+        rawResponse: import("drizzle-orm/pg-core").PgColumn<{
+            name: "raw_response";
+            tableName: "places";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        usageCount: import("drizzle-orm/pg-core").PgColumn<{
+            name: "usage_count";
+            tableName: "places";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        lastUsedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "last_used_at";
+            tableName: "places";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "places";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "places";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>, "enableRLS">;
+export type InsertRefPlace = typeof refPlacesTable.$inferInsert;
+export type SelectRefPlace = typeof refPlacesTable.$inferSelect;
+export declare const refPlaceInsertSchema: z.ZodObject<{
+    googlePlaceId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    name: z.ZodString;
+    translations: z.ZodNullable<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        address: z.ZodOptional<z.ZodString>;
+        formattedAddress: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>>;
+    countryCode: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    state: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    city: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    postalCode: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    streetAddress: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    latitude: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    longitude: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    types: z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    category: z.ZodNullable<z.ZodOptional<z.ZodEnum<{
+        port: "port";
+        address: "address";
+        other: "other";
+        country: "country";
+        city: "city";
+        hotel: "hotel";
+        restaurant: "restaurant";
+        airport: "airport";
+        attraction: "attraction";
+        transport_hub: "transport_hub";
+    }>>>;
+    timezone: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    viewport: z.ZodNullable<z.ZodOptional<z.ZodObject<{
+        northeast: z.ZodObject<{
+            lat: z.ZodNumber;
+            lng: z.ZodNumber;
+        }, z.core.$strip>;
+        southwest: z.ZodObject<{
+            lat: z.ZodNumber;
+            lng: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>>>;
+    rawResponse: z.ZodNullable<z.ZodOptional<z.ZodUnknown>>;
+}, z.core.$strip>;
+export declare const refPlaceUpdateSchema: z.ZodObject<{
+    googlePlaceId: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodString>>>;
+    name: z.ZodOptional<z.ZodString>;
+    translations: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        address: z.ZodOptional<z.ZodString>;
+        formattedAddress: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>>>;
+    countryCode: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodString>>>;
+    state: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodString>>>;
+    city: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodString>>>;
+    postalCode: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodString>>>;
+    streetAddress: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodString>>>;
+    latitude: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodNumber>>>;
+    longitude: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodNumber>>>;
+    types: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodString>>>>;
+    category: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodEnum<{
+        port: "port";
+        address: "address";
+        other: "other";
+        country: "country";
+        city: "city";
+        hotel: "hotel";
+        restaurant: "restaurant";
+        airport: "airport";
+        attraction: "attraction";
+        transport_hub: "transport_hub";
+    }>>>>;
+    timezone: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodString>>>;
+    viewport: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodObject<{
+        northeast: z.ZodObject<{
+            lat: z.ZodNumber;
+            lng: z.ZodNumber;
+        }, z.core.$strip>;
+        southwest: z.ZodObject<{
+            lat: z.ZodNumber;
+            lng: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>>>>;
+    rawResponse: z.ZodOptional<z.ZodNullable<z.ZodOptional<z.ZodUnknown>>>;
+}, z.core.$strip>;
+export declare const refPlaceSelectSchema: z.ZodObject<{
+    googlePlaceId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    name: z.ZodString;
+    translations: z.ZodNullable<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        address: z.ZodOptional<z.ZodString>;
+        formattedAddress: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>>;
+    countryCode: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    state: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    city: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    postalCode: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    streetAddress: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    latitude: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    longitude: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
+    types: z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    category: z.ZodNullable<z.ZodOptional<z.ZodEnum<{
+        port: "port";
+        address: "address";
+        other: "other";
+        country: "country";
+        city: "city";
+        hotel: "hotel";
+        restaurant: "restaurant";
+        airport: "airport";
+        attraction: "attraction";
+        transport_hub: "transport_hub";
+    }>>>;
+    timezone: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+    viewport: z.ZodNullable<z.ZodOptional<z.ZodObject<{
+        northeast: z.ZodObject<{
+            lat: z.ZodNumber;
+            lng: z.ZodNumber;
+        }, z.core.$strip>;
+        southwest: z.ZodObject<{
+            lat: z.ZodNumber;
+            lng: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>>>;
+    rawResponse: z.ZodNullable<z.ZodOptional<z.ZodUnknown>>;
+    id: z.ZodString;
+    usageCount: z.ZodDefault<z.ZodNumber>;
+    lastUsedAt: z.ZodNullable<z.ZodOptional<z.ZodDate>>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodNullable<z.ZodOptional<z.ZodDate>>;
+}, z.core.$strip>;
+export type RefPlace = z.infer<typeof refPlaceSelectSchema>;
+export type NewRefPlace = z.infer<typeof refPlaceInsertSchema>;
+export type UpdateRefPlace = z.infer<typeof refPlaceUpdateSchema>;
+/**
+ * Utility to derive category from Google place types
+ */
+export declare function deriveCategoryFromTypes(types: string[]): PlaceCategory;
+//# sourceMappingURL=places.d.ts.map

package/dist/schema/ref/places.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"places.d.ts","sourceRoot":"","sources":["../../../src/schema/ref/places.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAWH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,gBAAgB,CAAC,EAAE,MAAM,CAAA;CAC1B;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,SAAS,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAA;IACvC,SAAS,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAA;CACxC;AAED;;GAEG;AACH,MAAM,MAAM,aAAa,GACrB,SAAS,GACT,MAAM,GACN,SAAS,GACT,OAAO,GACP,YAAY,GACZ,YAAY,GACZ,eAAe,GACf,MAAM,GACN,SAAS,GACT,OAAO,CAAA;AAEX,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAiEb,CAAA;AAGd,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC,YAAY,CAAA;AAC/D,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC,YAAY,CAAA;AA6C/D,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAqB,CAAA;AACtD,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAA+B,CAAA;AAChE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAM/B,CAAA;AAEF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAC3D,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAC9D,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEjE;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,aAAa,CAqCtE"}

package/dist/schema/ref/places.js

@@ -0,0 +1,151 @@
+/**
+ * Reference Places Table
+ *
+ * Master table for all location/place data used across the platform.
+ * Stores Google Places data permanently to reduce API costs and enable
+ * offline access to location information.
+ *
+ * Key benefits:
+ * - Single source of truth for places (no duplicate API calls)
+ * - Multi-language translations stored as JSONB
+ * - Canonical coordinates for map rendering without API calls
+ * - Usage tracking for analytics and cache warming
+ */
+import { doublePrecision, index, integer, jsonb, text, timestamp, uniqueIndex, } from "drizzle-orm/pg-core";
+import { z } from "zod";
+import { typeId, typeIdSchema } from "../../lib/index.js";
+import { refSchema } from "../0_schemas.js";
+export const refPlacesTable = refSchema
+    .table("places", {
+    id: typeId("places"),
+    // Google Maps reference (immutable once set)
+    googlePlaceId: text("google_place_id").unique(),
+    // Canonical name (primary language, usually English)
+    name: text("name").notNull(),
+    // Localized names and addresses
+    // { "en": { name: "Paris", address: "Paris, France" },
+    //   "ro": { name: "Paris", address: "Paris, Franța" } }
+    translations: jsonb("translations").$type(),
+    // Parsed address components (denormalized for queries)
+    countryCode: text("country_code"), // ISO 3166-1 alpha-2
+    state: text("state"),
+    city: text("city"),
+    postalCode: text("postal_code"),
+    streetAddress: text("street_address"),
+    // Geometry (stable, never changes for a place)
+    latitude: doublePrecision("latitude"),
+    longitude: doublePrecision("longitude"),
+    // Google place types (for filtering)
+    // ["airport", "point_of_interest", "establishment"]
+    types: jsonb("types").$type(),
+    // Place category (derived from types for simpler filtering)
+    category: text("category").$type(),
+    // Timezone (useful for itineraries)
+    timezone: text("timezone"),
+    // Viewport for map rendering
+    viewport: jsonb("viewport").$type(),
+    // Raw Google response (for debugging/future parsing)
+    rawResponse: jsonb("raw_response"),
+    // Usage tracking
+    usageCount: integer("usage_count").default(0).notNull(),
+    lastUsedAt: timestamp("last_used_at", { withTimezone: true }),
+    // Metadata
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .defaultNow()
+        .notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }),
+}, (t) => [
+    uniqueIndex("places_google_place_id_idx").on(t.googlePlaceId),
+    index("places_country_code_idx").on(t.countryCode),
+    index("places_category_idx").on(t.category),
+    index("places_city_idx").on(t.city),
+    index("places_coords_idx").on(t.latitude, t.longitude),
+    index("places_name_idx").on(t.name),
+])
+    .enableRLS();
+// Zod schemas for validation
+const placeTranslationSchema = z.object({
+    name: z.string().optional(),
+    address: z.string().optional(),
+    formattedAddress: z.string().optional(),
+});
+const placeViewportSchema = z.object({
+    northeast: z.object({ lat: z.number(), lng: z.number() }),
+    southwest: z.object({ lat: z.number(), lng: z.number() }),
+});
+const placeCategorySchema = z.enum([
+    "airport",
+    "city",
+    "country",
+    "hotel",
+    "restaurant",
+    "attraction",
+    "transport_hub",
+    "port",
+    "address",
+    "other",
+]);
+const refPlaceCoreSchema = z.object({
+    googlePlaceId: z.string().optional().nullable(),
+    name: z.string().min(1, "Name is required"),
+    translations: z.record(z.string(), placeTranslationSchema).optional().nullable(),
+    countryCode: z.string().length(2).optional().nullable(),
+    state: z.string().optional().nullable(),
+    city: z.string().optional().nullable(),
+    postalCode: z.string().optional().nullable(),
+    streetAddress: z.string().optional().nullable(),
+    latitude: z.number().min(-90).max(90).optional().nullable(),
+    longitude: z.number().min(-180).max(180).optional().nullable(),
+    types: z.array(z.string()).optional().nullable(),
+    category: placeCategorySchema.optional().nullable(),
+    timezone: z.string().optional().nullable(),
+    viewport: placeViewportSchema.optional().nullable(),
+    rawResponse: z.unknown().optional().nullable(),
+});
+export const refPlaceInsertSchema = refPlaceCoreSchema;
+export const refPlaceUpdateSchema = refPlaceCoreSchema.partial();
+export const refPlaceSelectSchema = refPlaceCoreSchema.extend({
+    id: typeIdSchema("places"),
+    usageCount: z.number().default(0),
+    lastUsedAt: z.date().optional().nullable(),
+    createdAt: z.date(),
+    updatedAt: z.date().optional().nullable(),
+});
+/**
+ * Utility to derive category from Google place types
+ */
+export function deriveCategoryFromTypes(types) {
+    if (types.includes("airport") || types.includes("international_airport")) {
+        return "airport";
+    }
+    if (types.includes("locality") || types.includes("administrative_area_level_1")) {
+        return "city";
+    }
+    if (types.includes("country")) {
+        return "country";
+    }
+    if (types.includes("lodging") || types.includes("hotel")) {
+        return "hotel";
+    }
+    if (types.includes("restaurant") || types.includes("food")) {
+        return "restaurant";
+    }
+    if (types.includes("tourist_attraction") ||
+        types.includes("museum") ||
+        types.includes("park")) {
+        return "attraction";
+    }
+    if (types.includes("train_station") ||
+        types.includes("bus_station") ||
+        types.includes("transit_station")) {
+        return "transport_hub";
+    }
+    if (types.includes("harbor") || types.includes("port")) {
+        return "port";
+    }
+    if (types.includes("street_address") || types.includes("premise")) {
+        return "address";
+    }
+    return "other";
+}
+//# sourceMappingURL=places.js.map