includio-cms 0.0.2

package/dist/db-postgres/index.d.ts

@@ -0,0 +1,3 @@
+import type { Config } from './types.js';
+import type { DatabaseAdapter } from '../types/adapters.js';
+export declare function pg(config: Config): DatabaseAdapter;

package/dist/db-postgres/index.js

@@ -0,0 +1,249 @@
+import { drizzle } from 'drizzle-orm/postgres-js';
+import postgres from 'postgres';
+import * as schema from './schema/index.js';
+import { eq, and, inArray, getTableColumns, sql } from 'drizzle-orm';
+// Helper function to build JSON path conditions
+function buildJsonConditions(dataValue) {
+    const conditions = [];
+    function processValue(value, path = []) {
+        if (value === null || value === undefined) {
+            return;
+        }
+        if (typeof value === 'object' && !Array.isArray(value) && value !== null) {
+            // Recursively process nested objects
+            Object.entries(value).forEach(([key, nestedValue]) => {
+                processValue(nestedValue, [...path, key]);
+            });
+        }
+        else {
+            // Create condition for primitive values
+            const jsonPath = path.join(',');
+            const condition = sql `${schema.entriesTable.data}#>>'{${sql.raw(jsonPath)}}' = ${String(value)}`;
+            conditions.push(condition);
+        }
+    }
+    Object.entries(dataValue).forEach(([key, value]) => {
+        processValue(value, [key]);
+    });
+    return conditions;
+}
+export function pg(config) {
+    const client = postgres(config.databaseUrl);
+    const db = drizzle(client, { schema });
+    return {
+        createEntry: async ({ type, slug, status, data }) => {
+            return db.transaction(async (tx) => {
+                const result = await tx
+                    .insert(schema.entriesTable)
+                    .values({
+                    type,
+                    slug,
+                    data: data,
+                    status
+                })
+                    .returning();
+                const newEntry = {
+                    ...result[0],
+                    populated: false
+                };
+                return newEntry;
+            });
+        },
+        deleteEntry: async ({ id }) => {
+            await db.transaction(async (tx) => {
+                // await runHooks('beforeDelete', id, tx);
+                await tx
+                    .update(schema.entriesTable)
+                    .set({
+                    deletedAt: new Date()
+                })
+                    .where(eq(schema.entriesTable.id, id));
+            });
+        },
+        updateEntry: async ({ id, data }) => {
+            return db.transaction(async (tx) => {
+                // await runHooks('beforeUpdate', id, entry.slug, filteredData, tx);
+                const [result] = (await tx
+                    .update(schema.entriesTable)
+                    .set({
+                    ...data,
+                    updatedAt: new Date()
+                })
+                    .where(eq(schema.entriesTable.id, id))
+                    .returning());
+                return {
+                    ...result,
+                    populated: false
+                };
+            });
+        },
+        getEntries: async (options) => {
+            const query = db
+                .select({
+                ...getTableColumns(schema.entriesTable),
+                populated: sql `false`
+            })
+                .from(schema.entriesTable);
+            if (options.data) {
+                query.where(and(options.data.type ? eq(schema.entriesTable.type, options.data.type) : undefined, options.data.slug ? eq(schema.entriesTable.slug, options.data.slug) : undefined, options.data.ids ? inArray(schema.entriesTable.id, options.data.ids) : undefined));
+                if (options.data.ids) {
+                    query.where(inArray(schema.entriesTable.id, options.data.ids));
+                }
+            }
+            return (await query);
+        },
+        getEntry: async (options) => {
+            const query = db
+                .select({
+                ...getTableColumns(schema.entriesTable),
+                populated: sql `false`
+            })
+                .from(schema.entriesTable);
+            if (options.data) {
+                const baseConditions = [
+                    options.data.type ? eq(schema.entriesTable.type, options.data.type) : undefined,
+                    options.data.slug ? eq(schema.entriesTable.slug, options.data.slug) : undefined,
+                    options.data.id ? eq(schema.entriesTable.id, options.data.id) : undefined
+                ].filter(Boolean);
+                // Add JSON data conditions if dataValue is provided
+                const jsonConditions = options.data.dataValues
+                    ? buildJsonConditions(options.data.dataValues)
+                    : [];
+                const allConditions = [...baseConditions, ...jsonConditions];
+                if (allConditions.length > 0) {
+                    query.where(and(...allConditions));
+                }
+            }
+            const [entry] = await query;
+            return entry;
+        },
+        createMediaFolder: async (data) => {
+            return db
+                .insert(schema.mediaFoldersTable)
+                .values({
+                name: data.folderName,
+                parentId: data.parentId
+            })
+                .returning()
+                .then(([folder]) => folder);
+        },
+        getMediaFolders: async () => {
+            return db.select().from(schema.mediaFoldersTable);
+        },
+        createMediaFile: async (data) => {
+            return db
+                .insert(schema.mediaFilesTable)
+                .values(data)
+                .returning()
+                .then(([file]) => file);
+        },
+        getMediaFiles: async (options) => {
+            const query = db.select().from(schema.mediaFilesTable);
+            if (options.data) {
+                query.where(and(options.data.folderId
+                    ? eq(schema.mediaFilesTable.folderId, options.data.folderId)
+                    : undefined, options.data.ids ? inArray(schema.mediaFilesTable.id, options.data.ids) : undefined, options.data.mimeTypes
+                    ? inArray(schema.mediaFilesTable.mimeType, options.data.mimeTypes)
+                    : undefined));
+            }
+            return await query;
+        },
+        getMediaFile: async (options) => {
+            const query = db.select().from(schema.mediaFilesTable);
+            if (options.data) {
+                query.where(and(options.data.folderId
+                    ? eq(schema.mediaFilesTable.folderId, options.data.folderId)
+                    : undefined, options.data.id ? eq(schema.mediaFilesTable.id, options.data.id) : undefined));
+            }
+            const [mediaFile] = await query;
+            return mediaFile;
+        },
+        updateMediaFile: async (data) => {
+            return await db
+                .update(schema.mediaFilesTable)
+                .set(data.data)
+                .where(eq(schema.mediaFilesTable.id, data.id))
+                .returning()
+                .then(([file]) => file);
+        },
+        // User methods
+        getUser: async ({ data }) => {
+            const conditions = [];
+            if (data.id)
+                conditions.push(eq(schema.usersTable.id, data.id));
+            if (data.email)
+                conditions.push(eq(schema.usersTable.email, data.email));
+            if (data.googleId)
+                conditions.push(eq(schema.usersTable.googleId, data.googleId));
+            if (conditions.length === 0)
+                return null;
+            const [user] = await db
+                .select()
+                .from(schema.usersTable)
+                .where(and(...conditions));
+            return user || null;
+        },
+        getUsers: async (options) => {
+            const query = db.select().from(schema.usersTable);
+            if (options?.data?.ids) {
+                query.where(inArray(schema.usersTable.id, options.data.ids));
+            }
+            return await query;
+        },
+        createUser: async (data) => {
+            const [user] = await db.insert(schema.usersTable).values(data).returning();
+            return user;
+        },
+        updateUser: async (id, data) => {
+            const [user] = await db
+                .update(schema.usersTable)
+                .set(data)
+                .where(eq(schema.usersTable.id, id))
+                .returning();
+            return user || null;
+        },
+        // Session methods
+        createSession: async (data) => {
+            const [session] = await db.insert(schema.sessionsTable).values(data).returning();
+            return session;
+        },
+        getSession: async (sessionId) => {
+            const [session] = await db
+                .select()
+                .from(schema.sessionsTable)
+                .where(eq(schema.sessionsTable.id, sessionId));
+            return session || null;
+        },
+        getSessionWithUser: async (sessionId) => {
+            const [result] = await db
+                .select({
+                session: schema.sessionsTable,
+                user: schema.usersTable
+            })
+                .from(schema.sessionsTable)
+                .innerJoin(schema.usersTable, eq(schema.sessionsTable.userId, schema.usersTable.id))
+                .where(eq(schema.sessionsTable.id, sessionId));
+            if (!result) {
+                return { session: null, user: null };
+            }
+            return {
+                session: result.session,
+                user: result.user
+            };
+        },
+        deleteSession: async (sessionId) => {
+            await db.delete(schema.sessionsTable).where(eq(schema.sessionsTable.id, sessionId));
+        },
+        deleteUserSessions: async (userId) => {
+            await db.delete(schema.sessionsTable).where(eq(schema.sessionsTable.userId, userId));
+        },
+        updateSession: async (sessionId, data) => {
+            const [session] = await db
+                .update(schema.sessionsTable)
+                .set(data)
+                .where(eq(schema.sessionsTable.id, sessionId))
+                .returning();
+            return session || null;
+        }
+    };
+}

package/dist/db-postgres/schema/entry.d.ts

@@ -0,0 +1,177 @@
+export declare const entriesTable: import("drizzle-orm/pg-core/table", { with: { "resolution-mode": "require" } }).PgTableWithColumns<{
+    name: "entry";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "id";
+            tableName: "entry";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        slug: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "slug";
+            tableName: "entry";
+            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;
+        }, {}, {}>;
+        type: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "type";
+            tableName: "entry";
+            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;
+        }, {}, {}>;
+        status: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "status";
+            tableName: "entry";
+            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;
+        }, {}, {}>;
+        data: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "data";
+            tableName: "entry";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "created_at";
+            tableName: "entry";
+            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", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "updated_at";
+            tableName: "entry";
+            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;
+        }, {}, {}>;
+        deletedAt: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "deleted_at";
+            tableName: "entry";
+            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;
+        }, {}, {}>;
+        publishedAt: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "published_at";
+            tableName: "entry";
+            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;
+        }, {}, {}>;
+        archivedAt: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "archived_at";
+            tableName: "entry";
+            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";
+}>;

package/dist/db-postgres/schema/entry.js

@@ -0,0 +1,13 @@
+import { jsonb, pgTable, text, timestamp, uuid } from 'drizzle-orm/pg-core';
+export const entriesTable = pgTable('entry', {
+    id: uuid('id').primaryKey().defaultRandom(),
+    slug: text('slug').notNull(),
+    type: text('type').notNull(),
+    status: text('status').notNull(),
+    data: jsonb('data').notNull(),
+    createdAt: timestamp('created_at').defaultNow().notNull(),
+    updatedAt: timestamp('updated_at').defaultNow().notNull(),
+    deletedAt: timestamp('deleted_at'),
+    publishedAt: timestamp('published_at'),
+    archivedAt: timestamp('archived_at')
+});

package/dist/db-postgres/schema/index.d.ts

@@ -0,0 +1,5 @@
+export * from './entry.js';
+export * from './mediaFile.js';
+export * from './mediaFolder.js';
+export * from './session.js';
+export * from './user.js';

package/dist/db-postgres/schema/index.js

@@ -0,0 +1,5 @@
+export * from './entry.js';
+export * from './mediaFile.js';
+export * from './mediaFolder.js';
+export * from './session.js';
+export * from './user.js';