@hanzo/cms-drizzle 3.85.2

package/dist/migrateStatus.js

@@ -0,0 +1,44 @@
+import { Table } from 'console-table-printer';
+import { getMigrations, readMigrationFiles } from '@hanzo/cms';
+import { migrationTableExists } from './utilities/migrationTableExists.js';
+export async function migrateStatus() {
+    const { cms } = this;
+    const migrationFiles = await readMigrationFiles({
+        cms
+    });
+    cms.logger.debug({
+        msg: `Found ${migrationFiles.length} migration files.`
+    });
+    let existingMigrations = [];
+    const hasMigrationTable = await migrationTableExists(this);
+    if (hasMigrationTable) {
+        ;
+        ({ existingMigrations } = await getMigrations({
+            cms
+        }));
+    }
+    if (!migrationFiles.length) {
+        cms.logger.info({
+            msg: 'No migrations found.'
+        });
+        return;
+    }
+    // Compare migration files to existing migrations
+    const statuses = migrationFiles.map((migration)=>{
+        const existingMigration = existingMigrations.find((m)=>m.name === migration.name);
+        return {
+            Name: migration.name,
+            Batch: existingMigration?.batch,
+            Ran: existingMigration ? 'Yes' : 'No'
+        };
+    });
+    const p = new Table();
+    statuses.forEach((s)=>{
+        p.addRow(s, {
+            color: s.Ran === 'Yes' ? 'green' : 'red'
+        });
+    });
+    p.printTable();
+}
+
+//# sourceMappingURL=migrateStatus.js.map

package/dist/migrateStatus.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/migrateStatus.ts"],"sourcesContent":["import { Table } from 'console-table-printer'\nimport { getMigrations, readMigrationFiles } from '@hanzo/cms'\n\nimport type { DrizzleAdapter } from './types.js'\n\nimport { migrationTableExists } from './utilities/migrationTableExists.js'\n\nexport async function migrateStatus(this: DrizzleAdapter): Promise<void> {\n  const { cms } = this\n  const migrationFiles = await readMigrationFiles({ cms })\n\n  cms.logger.debug({\n    msg: `Found ${migrationFiles.length} migration files.`,\n  })\n\n  let existingMigrations = []\n  const hasMigrationTable = await migrationTableExists(this)\n\n  if (hasMigrationTable) {\n    ;({ existingMigrations } = await getMigrations({ cms }))\n  }\n\n  if (!migrationFiles.length) {\n    cms.logger.info({ msg: 'No migrations found.' })\n    return\n  }\n\n  // Compare migration files to existing migrations\n  const statuses = migrationFiles.map((migration) => {\n    const existingMigration = existingMigrations.find((m) => m.name === migration.name)\n    return {\n      Name: migration.name,\n\n      Batch: existingMigration?.batch,\n      Ran: existingMigration ? 'Yes' : 'No',\n    }\n  })\n\n  const p = new Table()\n\n  statuses.forEach((s) => {\n    p.addRow(s, {\n      color: s.Ran === 'Yes' ? 'green' : 'red',\n    })\n  })\n  p.printTable()\n}\n"],"names":["Table","getMigrations","readMigrationFiles","migrationTableExists","migrateStatus","cms","migrationFiles","logger","debug","msg","length","existingMigrations","hasMigrationTable","info","statuses","map","migration","existingMigration","find","m","name","Name","Batch","batch","Ran","p","forEach","s","addRow","color","printTable"],"mappings":"AAAA,SAASA,KAAK,QAAQ,wBAAuB;AAC7C,SAASC,aAAa,EAAEC,kBAAkB,QAAQ,aAAY;AAI9D,SAASC,oBAAoB,QAAQ,sCAAqC;AAE1E,OAAO,eAAeC;IACpB,MAAM,EAAEC,GAAG,EAAE,GAAG,IAAI;IACpB,MAAMC,iBAAiB,MAAMJ,mBAAmB;QAAEG;IAAI;IAEtDA,IAAIE,MAAM,CAACC,KAAK,CAAC;QACfC,KAAK,CAAC,MAAM,EAAEH,eAAeI,MAAM,CAAC,iBAAiB,CAAC;IACxD;IAEA,IAAIC,qBAAqB,EAAE;IAC3B,MAAMC,oBAAoB,MAAMT,qBAAqB,IAAI;IAEzD,IAAIS,mBAAmB;;QACnB,CAAA,EAAED,kBAAkB,EAAE,GAAG,MAAMV,cAAc;YAAEI;QAAI,EAAC;IACxD;IAEA,IAAI,CAACC,eAAeI,MAAM,EAAE;QAC1BL,IAAIE,MAAM,CAACM,IAAI,CAAC;YAAEJ,KAAK;QAAuB;QAC9C;IACF;IAEA,iDAAiD;IACjD,MAAMK,WAAWR,eAAeS,GAAG,CAAC,CAACC;QACnC,MAAMC,oBAAoBN,mBAAmBO,IAAI,CAAC,CAACC,IAAMA,EAAEC,IAAI,KAAKJ,UAAUI,IAAI;QAClF,OAAO;YACLC,MAAML,UAAUI,IAAI;YAEpBE,OAAOL,mBAAmBM;YAC1BC,KAAKP,oBAAoB,QAAQ;QACnC;IACF;IAEA,MAAMQ,IAAI,IAAIzB;IAEdc,SAASY,OAAO,CAAC,CAACC;QAChBF,EAAEG,MAAM,CAACD,GAAG;YACVE,OAAOF,EAAEH,GAAG,KAAK,QAAQ,UAAU;QACrC;IACF;IACAC,EAAEK,UAAU;AACd"}

package/dist/postgres/columnToCodeConverter.d.ts

@@ -0,0 +1,3 @@
+import type { ColumnToCodeConverter } from '../types.js';
+export declare const columnToCodeConverter: ColumnToCodeConverter;
+//# sourceMappingURL=columnToCodeConverter.d.ts.map

package/dist/postgres/columnToCodeConverter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"columnToCodeConverter.d.ts","sourceRoot":"","sources":["../../src/postgres/columnToCodeConverter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA;AACxD,eAAO,MAAM,qBAAqB,EAAE,qBAqHnC,CAAA"}

package/dist/postgres/columnToCodeConverter.js

@@ -0,0 +1,93 @@
+export const columnToCodeConverter = ({ adapter, addEnum, addImport, circularEdges, column, tableKey })=>{
+    let columnBuilderFn = column.type;
+    if (column.type === 'geometry') {
+        columnBuilderFn = 'geometryColumn';
+        addImport(adapter.packageName, columnBuilderFn);
+    } else if (column.type === 'enum') {
+        if ('locale' in column) {
+            columnBuilderFn = `enum__locales`;
+        } else {
+            addEnum(column.enumName, column.options);
+            columnBuilderFn = column.enumName;
+        }
+    } else {
+        addImport(`${adapter.packageName}/drizzle/pg-core`, columnBuilderFn);
+    }
+    const columnBuilderArgsArray = [];
+    switch(column.type){
+        case 'bit':
+        case 'halfvec':
+        case 'sparsevec':
+        case 'vector':
+            {
+                if (column.dimensions) {
+                    columnBuilderArgsArray.push(`dimensions: ${column.dimensions}`);
+                }
+                break;
+            }
+        case 'numeric':
+            {
+                columnBuilderArgsArray.push("mode: 'number'");
+                break;
+            }
+        case 'timestamp':
+            {
+                columnBuilderArgsArray.push(`mode: '${column.mode}'`);
+                if (column.withTimezone) {
+                    columnBuilderArgsArray.push('withTimezone: true');
+                }
+                if (typeof column.precision === 'number') {
+                    columnBuilderArgsArray.push(`precision: ${column.precision}`);
+                }
+                break;
+            }
+    }
+    let columnBuilderArgs = '';
+    if (columnBuilderArgsArray.length) {
+        columnBuilderArgs = `, {${columnBuilderArgsArray.join(',')}}`;
+    }
+    let code = `${columnBuilderFn}('${column.name}'${columnBuilderArgs})`;
+    if (column.type === 'timestamp' && column.defaultNow) {
+        code = `${code}.defaultNow()`;
+    }
+    if (column.type === 'uuid' && column.defaultRandom) {
+        code = `${code}.defaultRandom()`;
+    }
+    if (column.type === 'uuid' && column.defaultV7) {
+        addImport('uuid', 'v7 as uuidv7');
+        code = `${code}.$defaultFn(() => uuidv7())`;
+    }
+    if (column.notNull) {
+        code = `${code}.notNull()`;
+    }
+    if (column.primaryKey) {
+        code = `${code}.primaryKey()`;
+    }
+    if (typeof column.default !== 'undefined') {
+        let sanitizedDefault = column.default;
+        if (column.type === 'geometry') {
+            sanitizedDefault = `sql\`${column.default}\``;
+        } else if (column.type === 'jsonb') {
+            sanitizedDefault = `sql\`'${JSON.stringify(column.default)}'::jsonb\``;
+        } else if (column.type === 'numeric') {
+            sanitizedDefault = `${column.default}`;
+        } else if (typeof column.default === 'string') {
+            sanitizedDefault = `${JSON.stringify(column.default)}`;
+        }
+        code = `${code}.default(${sanitizedDefault})`;
+    }
+    if (column.reference) {
+        let callback = `()`;
+        if (column.reference.table === tableKey || circularEdges?.has(`${tableKey}:${column.reference.table}`)) {
+            addImport(`${adapter.packageName}/drizzle/pg-core`, 'type AnyPgColumn');
+            callback = `${callback}: AnyPgColumn`;
+        }
+        callback = `${callback} => ${column.reference.table}.${column.reference.name}`;
+        code = `${code}.references(${callback}, {
+      ${column.reference.onDelete ? `onDelete: '${column.reference.onDelete}'` : ''}
+  })`;
+    }
+    return code;
+};
+
+//# sourceMappingURL=columnToCodeConverter.js.map

package/dist/postgres/columnToCodeConverter.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/postgres/columnToCodeConverter.ts"],"sourcesContent":["import type { ColumnToCodeConverter } from '../types.js'\nexport const columnToCodeConverter: ColumnToCodeConverter = ({\n  adapter,\n  addEnum,\n  addImport,\n  circularEdges,\n  column,\n  tableKey,\n}) => {\n  let columnBuilderFn: string = column.type\n\n  if (column.type === 'geometry') {\n    columnBuilderFn = 'geometryColumn'\n    addImport(adapter.packageName, columnBuilderFn)\n  } else if (column.type === 'enum') {\n    if ('locale' in column) {\n      columnBuilderFn = `enum__locales`\n    } else {\n      addEnum(column.enumName, column.options)\n      columnBuilderFn = column.enumName\n    }\n  } else {\n    addImport(`${adapter.packageName}/drizzle/pg-core`, columnBuilderFn)\n  }\n\n  const columnBuilderArgsArray: string[] = []\n\n  switch (column.type) {\n    case 'bit':\n    case 'halfvec':\n    case 'sparsevec':\n    case 'vector': {\n      if (column.dimensions) {\n        columnBuilderArgsArray.push(`dimensions: ${column.dimensions}`)\n      }\n      break\n    }\n    case 'numeric': {\n      columnBuilderArgsArray.push(\"mode: 'number'\")\n      break\n    }\n    case 'timestamp': {\n      columnBuilderArgsArray.push(`mode: '${column.mode}'`)\n      if (column.withTimezone) {\n        columnBuilderArgsArray.push('withTimezone: true')\n      }\n\n      if (typeof column.precision === 'number') {\n        columnBuilderArgsArray.push(`precision: ${column.precision}`)\n      }\n      break\n    }\n  }\n\n  let columnBuilderArgs = ''\n\n  if (columnBuilderArgsArray.length) {\n    columnBuilderArgs = `, {${columnBuilderArgsArray.join(',')}}`\n  }\n\n  let code = `${columnBuilderFn}('${column.name}'${columnBuilderArgs})`\n\n  if (column.type === 'timestamp' && column.defaultNow) {\n    code = `${code}.defaultNow()`\n  }\n\n  if (column.type === 'uuid' && column.defaultRandom) {\n    code = `${code}.defaultRandom()`\n  }\n\n  if (column.type === 'uuid' && column.defaultV7) {\n    addImport('uuid', 'v7 as uuidv7')\n    code = `${code}.$defaultFn(() => uuidv7())`\n  }\n\n  if (column.notNull) {\n    code = `${code}.notNull()`\n  }\n\n  if (column.primaryKey) {\n    code = `${code}.primaryKey()`\n  }\n\n  if (typeof column.default !== 'undefined') {\n    let sanitizedDefault = column.default\n\n    if (column.type === 'geometry') {\n      sanitizedDefault = `sql\\`${column.default}\\``\n    } else if (column.type === 'jsonb') {\n      sanitizedDefault = `sql\\`'${JSON.stringify(column.default)}'::jsonb\\``\n    } else if (column.type === 'numeric') {\n      sanitizedDefault = `${column.default}`\n    } else if (typeof column.default === 'string') {\n      sanitizedDefault = `${JSON.stringify(column.default)}`\n    }\n\n    code = `${code}.default(${sanitizedDefault})`\n  }\n\n  if (column.reference) {\n    let callback = `()`\n\n    if (\n      column.reference.table === tableKey ||\n      circularEdges?.has(`${tableKey}:${column.reference.table}`)\n    ) {\n      addImport(`${adapter.packageName}/drizzle/pg-core`, 'type AnyPgColumn')\n      callback = `${callback}: AnyPgColumn`\n    }\n\n    callback = `${callback} => ${column.reference.table}.${column.reference.name}`\n\n    code = `${code}.references(${callback}, {\n      ${column.reference.onDelete ? `onDelete: '${column.reference.onDelete}'` : ''}\n  })`\n  }\n\n  return code\n}\n"],"names":["columnToCodeConverter","adapter","addEnum","addImport","circularEdges","column","tableKey","columnBuilderFn","type","packageName","enumName","options","columnBuilderArgsArray","dimensions","push","mode","withTimezone","precision","columnBuilderArgs","length","join","code","name","defaultNow","defaultRandom","defaultV7","notNull","primaryKey","default","sanitizedDefault","JSON","stringify","reference","callback","table","has","onDelete"],"mappings":"AACA,OAAO,MAAMA,wBAA+C,CAAC,EAC3DC,OAAO,EACPC,OAAO,EACPC,SAAS,EACTC,aAAa,EACbC,MAAM,EACNC,QAAQ,EACT;IACC,IAAIC,kBAA0BF,OAAOG,IAAI;IAEzC,IAAIH,OAAOG,IAAI,KAAK,YAAY;QAC9BD,kBAAkB;QAClBJ,UAAUF,QAAQQ,WAAW,EAAEF;IACjC,OAAO,IAAIF,OAAOG,IAAI,KAAK,QAAQ;QACjC,IAAI,YAAYH,QAAQ;YACtBE,kBAAkB,CAAC,aAAa,CAAC;QACnC,OAAO;YACLL,QAAQG,OAAOK,QAAQ,EAAEL,OAAOM,OAAO;YACvCJ,kBAAkBF,OAAOK,QAAQ;QACnC;IACF,OAAO;QACLP,UAAU,GAAGF,QAAQQ,WAAW,CAAC,gBAAgB,CAAC,EAAEF;IACtD;IAEA,MAAMK,yBAAmC,EAAE;IAE3C,OAAQP,OAAOG,IAAI;QACjB,KAAK;QACL,KAAK;QACL,KAAK;QACL,KAAK;YAAU;gBACb,IAAIH,OAAOQ,UAAU,EAAE;oBACrBD,uBAAuBE,IAAI,CAAC,CAAC,YAAY,EAAET,OAAOQ,UAAU,EAAE;gBAChE;gBACA;YACF;QACA,KAAK;YAAW;gBACdD,uBAAuBE,IAAI,CAAC;gBAC5B;YACF;QACA,KAAK;YAAa;gBAChBF,uBAAuBE,IAAI,CAAC,CAAC,OAAO,EAAET,OAAOU,IAAI,CAAC,CAAC,CAAC;gBACpD,IAAIV,OAAOW,YAAY,EAAE;oBACvBJ,uBAAuBE,IAAI,CAAC;gBAC9B;gBAEA,IAAI,OAAOT,OAAOY,SAAS,KAAK,UAAU;oBACxCL,uBAAuBE,IAAI,CAAC,CAAC,WAAW,EAAET,OAAOY,SAAS,EAAE;gBAC9D;gBACA;YACF;IACF;IAEA,IAAIC,oBAAoB;IAExB,IAAIN,uBAAuBO,MAAM,EAAE;QACjCD,oBAAoB,CAAC,GAAG,EAAEN,uBAAuBQ,IAAI,CAAC,KAAK,CAAC,CAAC;IAC/D;IAEA,IAAIC,OAAO,GAAGd,gBAAgB,EAAE,EAAEF,OAAOiB,IAAI,CAAC,CAAC,EAAEJ,kBAAkB,CAAC,CAAC;IAErE,IAAIb,OAAOG,IAAI,KAAK,eAAeH,OAAOkB,UAAU,EAAE;QACpDF,OAAO,GAAGA,KAAK,aAAa,CAAC;IAC/B;IAEA,IAAIhB,OAAOG,IAAI,KAAK,UAAUH,OAAOmB,aAAa,EAAE;QAClDH,OAAO,GAAGA,KAAK,gBAAgB,CAAC;IAClC;IAEA,IAAIhB,OAAOG,IAAI,KAAK,UAAUH,OAAOoB,SAAS,EAAE;QAC9CtB,UAAU,QAAQ;QAClBkB,OAAO,GAAGA,KAAK,2BAA2B,CAAC;IAC7C;IAEA,IAAIhB,OAAOqB,OAAO,EAAE;QAClBL,OAAO,GAAGA,KAAK,UAAU,CAAC;IAC5B;IAEA,IAAIhB,OAAOsB,UAAU,EAAE;QACrBN,OAAO,GAAGA,KAAK,aAAa,CAAC;IAC/B;IAEA,IAAI,OAAOhB,OAAOuB,OAAO,KAAK,aAAa;QACzC,IAAIC,mBAAmBxB,OAAOuB,OAAO;QAErC,IAAIvB,OAAOG,IAAI,KAAK,YAAY;YAC9BqB,mBAAmB,CAAC,KAAK,EAAExB,OAAOuB,OAAO,CAAC,EAAE,CAAC;QAC/C,OAAO,IAAIvB,OAAOG,IAAI,KAAK,SAAS;YAClCqB,mBAAmB,CAAC,MAAM,EAAEC,KAAKC,SAAS,CAAC1B,OAAOuB,OAAO,EAAE,UAAU,CAAC;QACxE,OAAO,IAAIvB,OAAOG,IAAI,KAAK,WAAW;YACpCqB,mBAAmB,GAAGxB,OAAOuB,OAAO,EAAE;QACxC,OAAO,IAAI,OAAOvB,OAAOuB,OAAO,KAAK,UAAU;YAC7CC,mBAAmB,GAAGC,KAAKC,SAAS,CAAC1B,OAAOuB,OAAO,GAAG;QACxD;QAEAP,OAAO,GAAGA,KAAK,SAAS,EAAEQ,iBAAiB,CAAC,CAAC;IAC/C;IAEA,IAAIxB,OAAO2B,SAAS,EAAE;QACpB,IAAIC,WAAW,CAAC,EAAE,CAAC;QAEnB,IACE5B,OAAO2B,SAAS,CAACE,KAAK,KAAK5B,YAC3BF,eAAe+B,IAAI,GAAG7B,SAAS,CAAC,EAAED,OAAO2B,SAAS,CAACE,KAAK,EAAE,GAC1D;YACA/B,UAAU,GAAGF,QAAQQ,WAAW,CAAC,gBAAgB,CAAC,EAAE;YACpDwB,WAAW,GAAGA,SAAS,aAAa,CAAC;QACvC;QAEAA,WAAW,GAAGA,SAAS,IAAI,EAAE5B,OAAO2B,SAAS,CAACE,KAAK,CAAC,CAAC,EAAE7B,OAAO2B,SAAS,CAACV,IAAI,EAAE;QAE9ED,OAAO,GAAGA,KAAK,YAAY,EAAEY,SAAS;MACpC,EAAE5B,OAAO2B,SAAS,CAACI,QAAQ,GAAG,CAAC,WAAW,EAAE/B,OAAO2B,SAAS,CAACI,QAAQ,CAAC,CAAC,CAAC,GAAG,GAAG;IAChF,CAAC;IACH;IAEA,OAAOf;AACT,EAAC"}

package/dist/postgres/countDistinct.d.ts

@@ -0,0 +1,3 @@
+import type { CountDistinct } from './types.js';
+export declare const countDistinct: CountDistinct;
+//# sourceMappingURL=countDistinct.d.ts.map

package/dist/postgres/countDistinct.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"countDistinct.d.ts","sourceRoot":"","sources":["../../src/postgres/countDistinct.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAuB,aAAa,EAAE,MAAM,YAAY,CAAA;AAEpE,eAAO,MAAM,aAAa,EAAE,aAqC3B,CAAA"}

package/dist/postgres/countDistinct.js

@@ -0,0 +1,24 @@
+import { count, sql } from 'drizzle-orm';
+export const countDistinct = async function countDistinct({ column, db, joins, tableName, where }) {
+    // When we don't have any joins - use a simple COUNT(*) query.
+    if (joins.length === 0) {
+        const countResult = await db.select({
+            count: column ? count(sql`DISTINCT ${column}`) : count()
+        }).from(this.tables[tableName]).where(where);
+        return Number(countResult?.[0]?.count ?? 0);
+    }
+    let query = db.select({
+        count: sql`COUNT(1) OVER()`
+    }).from(this.tables[tableName]).where(where).groupBy(column || this.tables[tableName].id).limit(1).$dynamic();
+    joins.forEach(({ type, condition, table })=>{
+        query = query[type ?? 'leftJoin'](table, condition);
+    });
+    // When we have any joins, we need to count each individual ID only once.
+    // COUNT(*) doesn't work for this well in this case, as it also counts joined tables.
+    // SELECT (COUNT DISTINCT id) has a very slow performance on large tables.
+    // Instead, COUNT (GROUP BY id) can be used which is still slower than COUNT(*) but acceptable.
+    const countResult = await query;
+    return Number(countResult?.[0]?.count ?? 0);
+};
+
+//# sourceMappingURL=countDistinct.js.map

package/dist/postgres/countDistinct.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/postgres/countDistinct.ts"],"sourcesContent":["import type { PgTableWithColumns } from 'drizzle-orm/pg-core'\n\nimport { count, sql } from 'drizzle-orm'\n\nimport type { BasePostgresAdapter, CountDistinct } from './types.js'\n\nexport const countDistinct: CountDistinct = async function countDistinct(\n  this: BasePostgresAdapter,\n  { column, db, joins, tableName, where },\n) {\n  // When we don't have any joins - use a simple COUNT(*) query.\n  if (joins.length === 0) {\n    const countResult = await db\n      .select({\n        count: column ? count(sql`DISTINCT ${column}`) : count(),\n      })\n      .from(this.tables[tableName])\n      .where(where)\n\n    return Number(countResult?.[0]?.count ?? 0)\n  }\n\n  let query = db\n    .select({\n      count: sql`COUNT(1) OVER()`,\n    })\n    .from(this.tables[tableName])\n    .where(where)\n    .groupBy(column || this.tables[tableName].id)\n    .limit(1)\n    .$dynamic()\n\n  joins.forEach(({ type, condition, table }) => {\n    query = query[type ?? 'leftJoin'](table as PgTableWithColumns<any>, condition)\n  })\n\n  // When we have any joins, we need to count each individual ID only once.\n  // COUNT(*) doesn't work for this well in this case, as it also counts joined tables.\n  // SELECT (COUNT DISTINCT id) has a very slow performance on large tables.\n  // Instead, COUNT (GROUP BY id) can be used which is still slower than COUNT(*) but acceptable.\n  const countResult = await query\n\n  return Number(countResult?.[0]?.count ?? 0)\n}\n"],"names":["count","sql","countDistinct","column","db","joins","tableName","where","length","countResult","select","from","tables","Number","query","groupBy","id","limit","$dynamic","forEach","type","condition","table"],"mappings":"AAEA,SAASA,KAAK,EAAEC,GAAG,QAAQ,cAAa;AAIxC,OAAO,MAAMC,gBAA+B,eAAeA,cAEzD,EAAEC,MAAM,EAAEC,EAAE,EAAEC,KAAK,EAAEC,SAAS,EAAEC,KAAK,EAAE;IAEvC,8DAA8D;IAC9D,IAAIF,MAAMG,MAAM,KAAK,GAAG;QACtB,MAAMC,cAAc,MAAML,GACvBM,MAAM,CAAC;YACNV,OAAOG,SAASH,MAAMC,GAAG,CAAC,SAAS,EAAEE,OAAO,CAAC,IAAIH;QACnD,GACCW,IAAI,CAAC,IAAI,CAACC,MAAM,CAACN,UAAU,EAC3BC,KAAK,CAACA;QAET,OAAOM,OAAOJ,aAAa,CAAC,EAAE,EAAET,SAAS;IAC3C;IAEA,IAAIc,QAAQV,GACTM,MAAM,CAAC;QACNV,OAAOC,GAAG,CAAC,eAAe,CAAC;IAC7B,GACCU,IAAI,CAAC,IAAI,CAACC,MAAM,CAACN,UAAU,EAC3BC,KAAK,CAACA,OACNQ,OAAO,CAACZ,UAAU,IAAI,CAACS,MAAM,CAACN,UAAU,CAACU,EAAE,EAC3CC,KAAK,CAAC,GACNC,QAAQ;IAEXb,MAAMc,OAAO,CAAC,CAAC,EAAEC,IAAI,EAAEC,SAAS,EAAEC,KAAK,EAAE;QACvCR,QAAQA,KAAK,CAACM,QAAQ,WAAW,CAACE,OAAkCD;IACtE;IAEA,yEAAyE;IACzE,qFAAqF;IACrF,0EAA0E;IAC1E,+FAA+F;IAC/F,MAAMZ,cAAc,MAAMK;IAE1B,OAAOD,OAAOJ,aAAa,CAAC,EAAE,EAAET,SAAS;AAC3C,EAAC"}

package/dist/postgres/createDatabase.d.ts

@@ -0,0 +1,14 @@
+import type { BasePostgresAdapter } from './types.js';
+type Args = {
+    /**
+     * Name of a database, defaults to the current one
+     */
+    name?: string;
+    /**
+     * Schema to create in addition to 'public'. Defaults to adapter.schemaName if exists.
+     */
+    schemaName?: string;
+};
+export declare const createDatabase: (this: BasePostgresAdapter, args?: Args) => Promise<boolean>;
+export {};
+//# sourceMappingURL=createDatabase.d.ts.map

package/dist/postgres/createDatabase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createDatabase.d.ts","sourceRoot":"","sources":["../../src/postgres/createDatabase.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAA;AAgBrD,KAAK,IAAI,GAAG;IACV;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,CAAA;IACb;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB,CAAA;AACD,eAAO,MAAM,cAAc,SAAyB,mBAAmB,SAAQ,IAAI,qBAkFlF,CAAA"}

package/dist/postgres/createDatabase.js

@@ -0,0 +1,76 @@
+const setConnectionStringDatabase = ({ connectionString, database })=>{
+    const connectionURL = new URL(connectionString);
+    const newConnectionURL = new URL(connectionURL);
+    newConnectionURL.pathname = `/${database}`;
+    return newConnectionURL.toString();
+};
+export const createDatabase = async function(args = {}) {
+    // POSTGRES_URL - default Vercel env
+    const connectionString = this.poolOptions?.connectionString ?? process.env.POSTGRES_URL ?? process.env.DATABASE_URL;
+    let managementClientConfig = {};
+    let dbName = args.name;
+    const schemaName = this.schemaName || 'public';
+    if (connectionString) {
+        if (!dbName) {
+            dbName = new URL(connectionString).pathname.slice(1);
+        }
+        managementClientConfig.connectionString = setConnectionStringDatabase({
+            connectionString,
+            database: 'postgres'
+        });
+    } else {
+        if (!dbName) {
+            dbName = this.poolOptions.database;
+        }
+        managementClientConfig = {
+            ...this.poolOptions,
+            database: 'postgres'
+        };
+    }
+    // import pg only when createDatabase is used
+    const pg = await import('pg').then((mod)=>mod.default);
+    const managementClient = new pg.Client(managementClientConfig);
+    try {
+        await managementClient.connect();
+        await managementClient.query(`CREATE DATABASE "${dbName}"`);
+        this.cms.logger.info(`Created database "${dbName}"`);
+        if (schemaName !== 'public') {
+            let createdDatabaseConfig = {};
+            if (connectionString) {
+                createdDatabaseConfig.connectionString = setConnectionStringDatabase({
+                    connectionString,
+                    database: dbName
+                });
+            } else {
+                createdDatabaseConfig = {
+                    ...this.poolOptions,
+                    database: dbName
+                };
+            }
+            const createdDatabaseClient = new pg.Client(createdDatabaseConfig);
+            try {
+                await createdDatabaseClient.connect();
+                await createdDatabaseClient.query(`CREATE SCHEMA ${schemaName}`);
+                this.cms.logger.info(`Created schema "${dbName}.${schemaName}"`);
+            } catch (err) {
+                this.cms.logger.error({
+                    err,
+                    msg: `Error: failed to create schema "${dbName}.${schemaName}". Details: ${err.message}`
+                });
+            } finally{
+                await createdDatabaseClient.end();
+            }
+        }
+        return true;
+    } catch (err) {
+        this.cms.logger.error({
+            err,
+            msg: `Error: failed to create database ${dbName}. Details: ${err.message}`
+        });
+        return false;
+    } finally{
+        await managementClient.end();
+    }
+};
+
+//# sourceMappingURL=createDatabase.js.map

package/dist/postgres/createDatabase.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/postgres/createDatabase.ts"],"sourcesContent":["import type { ClientConfig } from 'pg'\n\nimport type { BasePostgresAdapter } from './types.js'\n\nconst setConnectionStringDatabase = ({\n  connectionString,\n  database,\n}: {\n  connectionString: string\n  database: string\n}): string => {\n  const connectionURL = new URL(connectionString)\n  const newConnectionURL = new URL(connectionURL)\n  newConnectionURL.pathname = `/${database}`\n\n  return newConnectionURL.toString()\n}\n\ntype Args = {\n  /**\n   * Name of a database, defaults to the current one\n   */\n  name?: string\n  /**\n   * Schema to create in addition to 'public'. Defaults to adapter.schemaName if exists.\n   */\n  schemaName?: string\n}\nexport const createDatabase = async function (this: BasePostgresAdapter, args: Args = {}) {\n  // POSTGRES_URL - default Vercel env\n  const connectionString =\n    this.poolOptions?.connectionString ?? process.env.POSTGRES_URL ?? process.env.DATABASE_URL\n  let managementClientConfig: ClientConfig = {}\n  let dbName = args.name\n  const schemaName = this.schemaName || 'public'\n\n  if (connectionString) {\n    if (!dbName) {\n      dbName = new URL(connectionString).pathname.slice(1)\n    }\n\n    managementClientConfig.connectionString = setConnectionStringDatabase({\n      connectionString,\n      database: 'postgres',\n    })\n  } else {\n    if (!dbName) {\n      dbName = this.poolOptions.database\n    }\n\n    managementClientConfig = {\n      ...this.poolOptions,\n      database: 'postgres',\n    }\n  }\n\n  // import pg only when createDatabase is used\n  const pg = await import('pg').then((mod) => mod.default)\n\n  const managementClient = new pg.Client(managementClientConfig)\n\n  try {\n    await managementClient.connect()\n    await managementClient.query(`CREATE DATABASE \"${dbName}\"`)\n\n    this.cms.logger.info(`Created database \"${dbName}\"`)\n\n    if (schemaName !== 'public') {\n      let createdDatabaseConfig: ClientConfig = {}\n\n      if (connectionString) {\n        createdDatabaseConfig.connectionString = setConnectionStringDatabase({\n          connectionString,\n          database: dbName,\n        })\n      } else {\n        createdDatabaseConfig = {\n          ...this.poolOptions,\n          database: dbName,\n        }\n      }\n\n      const createdDatabaseClient = new pg.Client(createdDatabaseConfig)\n\n      try {\n        await createdDatabaseClient.connect()\n\n        await createdDatabaseClient.query(`CREATE SCHEMA ${schemaName}`)\n        this.cms.logger.info(`Created schema \"${dbName}.${schemaName}\"`)\n      } catch (err) {\n        this.cms.logger.error({\n          err,\n          msg: `Error: failed to create schema \"${dbName}.${schemaName}\". Details: ${err.message}`,\n        })\n      } finally {\n        await createdDatabaseClient.end()\n      }\n    }\n\n    return true\n  } catch (err) {\n    this.cms.logger.error({\n      err,\n      msg: `Error: failed to create database ${dbName}. Details: ${err.message}`,\n    })\n\n    return false\n  } finally {\n    await managementClient.end()\n  }\n}\n"],"names":["setConnectionStringDatabase","connectionString","database","connectionURL","URL","newConnectionURL","pathname","toString","createDatabase","args","poolOptions","process","env","POSTGRES_URL","DATABASE_URL","managementClientConfig","dbName","name","schemaName","slice","pg","then","mod","default","managementClient","Client","connect","query","cms","logger","info","createdDatabaseConfig","createdDatabaseClient","err","error","msg","message","end"],"mappings":"AAIA,MAAMA,8BAA8B,CAAC,EACnCC,gBAAgB,EAChBC,QAAQ,EAIT;IACC,MAAMC,gBAAgB,IAAIC,IAAIH;IAC9B,MAAMI,mBAAmB,IAAID,IAAID;IACjCE,iBAAiBC,QAAQ,GAAG,CAAC,CAAC,EAAEJ,UAAU;IAE1C,OAAOG,iBAAiBE,QAAQ;AAClC;AAYA,OAAO,MAAMC,iBAAiB,eAA2CC,OAAa,CAAC,CAAC;IACtF,oCAAoC;IACpC,MAAMR,mBACJ,IAAI,CAACS,WAAW,EAAET,oBAAoBU,QAAQC,GAAG,CAACC,YAAY,IAAIF,QAAQC,GAAG,CAACE,YAAY;IAC5F,IAAIC,yBAAuC,CAAC;IAC5C,IAAIC,SAASP,KAAKQ,IAAI;IACtB,MAAMC,aAAa,IAAI,CAACA,UAAU,IAAI;IAEtC,IAAIjB,kBAAkB;QACpB,IAAI,CAACe,QAAQ;YACXA,SAAS,IAAIZ,IAAIH,kBAAkBK,QAAQ,CAACa,KAAK,CAAC;QACpD;QAEAJ,uBAAuBd,gBAAgB,GAAGD,4BAA4B;YACpEC;YACAC,UAAU;QACZ;IACF,OAAO;QACL,IAAI,CAACc,QAAQ;YACXA,SAAS,IAAI,CAACN,WAAW,CAACR,QAAQ;QACpC;QAEAa,yBAAyB;YACvB,GAAG,IAAI,CAACL,WAAW;YACnBR,UAAU;QACZ;IACF;IAEA,6CAA6C;IAC7C,MAAMkB,KAAK,MAAM,MAAM,CAAC,MAAMC,IAAI,CAAC,CAACC,MAAQA,IAAIC,OAAO;IAEvD,MAAMC,mBAAmB,IAAIJ,GAAGK,MAAM,CAACV;IAEvC,IAAI;QACF,MAAMS,iBAAiBE,OAAO;QAC9B,MAAMF,iBAAiBG,KAAK,CAAC,CAAC,iBAAiB,EAAEX,OAAO,CAAC,CAAC;QAE1D,IAAI,CAACY,GAAG,CAACC,MAAM,CAACC,IAAI,CAAC,CAAC,kBAAkB,EAAEd,OAAO,CAAC,CAAC;QAEnD,IAAIE,eAAe,UAAU;YAC3B,IAAIa,wBAAsC,CAAC;YAE3C,IAAI9B,kBAAkB;gBACpB8B,sBAAsB9B,gBAAgB,GAAGD,4BAA4B;oBACnEC;oBACAC,UAAUc;gBACZ;YACF,OAAO;gBACLe,wBAAwB;oBACtB,GAAG,IAAI,CAACrB,WAAW;oBACnBR,UAAUc;gBACZ;YACF;YAEA,MAAMgB,wBAAwB,IAAIZ,GAAGK,MAAM,CAACM;YAE5C,IAAI;gBACF,MAAMC,sBAAsBN,OAAO;gBAEnC,MAAMM,sBAAsBL,KAAK,CAAC,CAAC,cAAc,EAAET,YAAY;gBAC/D,IAAI,CAACU,GAAG,CAACC,MAAM,CAACC,IAAI,CAAC,CAAC,gBAAgB,EAAEd,OAAO,CAAC,EAAEE,WAAW,CAAC,CAAC;YACjE,EAAE,OAAOe,KAAK;gBACZ,IAAI,CAACL,GAAG,CAACC,MAAM,CAACK,KAAK,CAAC;oBACpBD;oBACAE,KAAK,CAAC,gCAAgC,EAAEnB,OAAO,CAAC,EAAEE,WAAW,YAAY,EAAEe,IAAIG,OAAO,EAAE;gBAC1F;YACF,SAAU;gBACR,MAAMJ,sBAAsBK,GAAG;YACjC;QACF;QAEA,OAAO;IACT,EAAE,OAAOJ,KAAK;QACZ,IAAI,CAACL,GAAG,CAACC,MAAM,CAACK,KAAK,CAAC;YACpBD;YACAE,KAAK,CAAC,iCAAiC,EAAEnB,OAAO,WAAW,EAAEiB,IAAIG,OAAO,EAAE;QAC5E;QAEA,OAAO;IACT,SAAU;QACR,MAAMZ,iBAAiBa,GAAG;IAC5B;AACF,EAAC"}

package/dist/postgres/createExtensions.d.ts

@@ -0,0 +1,3 @@
+import type { BasePostgresAdapter } from './types.js';
+export declare const createExtensions: (this: BasePostgresAdapter) => Promise<void>;
+//# sourceMappingURL=createExtensions.d.ts.map

package/dist/postgres/createExtensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createExtensions.d.ts","sourceRoot":"","sources":["../../src/postgres/createExtensions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAA;AAErD,eAAO,MAAM,gBAAgB,SAAyB,mBAAmB,KAAG,OAAO,CAAC,IAAI,CAUvF,CAAA"}

package/dist/postgres/createExtensions.js

@@ -0,0 +1,16 @@
+export const createExtensions = async function() {
+    for(const extension in this.extensions){
+        if (this.extensions[extension]) {
+            try {
+                await this.drizzle.execute(`CREATE EXTENSION IF NOT EXISTS "${extension}"`);
+            } catch (err) {
+                this.cms.logger.error({
+                    err,
+                    msg: `Failed to create extension ${extension}`
+                });
+            }
+        }
+    }
+};
+
+//# sourceMappingURL=createExtensions.js.map

package/dist/postgres/createExtensions.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/postgres/createExtensions.ts"],"sourcesContent":["import type { BasePostgresAdapter } from './types.js'\n\nexport const createExtensions = async function (this: BasePostgresAdapter): Promise<void> {\n  for (const extension in this.extensions) {\n    if (this.extensions[extension]) {\n      try {\n        await this.drizzle.execute(`CREATE EXTENSION IF NOT EXISTS \"${extension}\"`)\n      } catch (err) {\n        this.cms.logger.error({ err, msg: `Failed to create extension ${extension}` })\n      }\n    }\n  }\n}\n"],"names":["createExtensions","extension","extensions","drizzle","execute","err","cms","logger","error","msg"],"mappings":"AAEA,OAAO,MAAMA,mBAAmB;IAC9B,IAAK,MAAMC,aAAa,IAAI,CAACC,UAAU,CAAE;QACvC,IAAI,IAAI,CAACA,UAAU,CAACD,UAAU,EAAE;YAC9B,IAAI;gBACF,MAAM,IAAI,CAACE,OAAO,CAACC,OAAO,CAAC,CAAC,gCAAgC,EAAEH,UAAU,CAAC,CAAC;YAC5E,EAAE,OAAOI,KAAK;gBACZ,IAAI,CAACC,GAAG,CAACC,MAAM,CAACC,KAAK,CAAC;oBAAEH;oBAAKI,KAAK,CAAC,2BAA2B,EAAER,WAAW;gBAAC;YAC9E;QACF;IACF;AACF,EAAC"}

package/dist/postgres/createJSONQuery/index.d.ts

@@ -0,0 +1,3 @@
+import type { CreateJSONQueryArgs } from '../../types.js';
+export declare const createJSONQuery: ({ column, operator, pathSegments, value }: CreateJSONQueryArgs) => string;
+//# sourceMappingURL=index.d.ts.map

package/dist/postgres/createJSONQuery/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/postgres/createJSONQuery/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAA;AAuCzD,eAAO,MAAM,eAAe,8CAA+C,mBAAmB,WA8B7F,CAAA"}

package/dist/postgres/createJSONQuery/index.js

@@ -0,0 +1,67 @@
+import { APIError } from '@hanzo/cms';
+import { SAFE_STRING_REGEX } from '../../utilities/escapeSQLValue.js';
+import { sanitizePathSegment } from '../../utilities/sanitizePathSegment.js';
+const operatorMap = {
+    contains: '~',
+    equals: '==',
+    in: 'in',
+    like: 'like_regex',
+    not_equals: '!=',
+    not_in: 'in',
+    not_like: '!like_regex'
+};
+const sanitizeValue = (value, operator)=>{
+    if (value === null) {
+        return `NULL`;
+    }
+    if (typeof value === 'number' || typeof value === 'boolean') {
+        return `${value}`;
+    }
+    if (typeof value !== 'string') {
+        throw new Error('Invalid value type');
+    }
+    if (!SAFE_STRING_REGEX.test(value)) {
+        throw new APIError(`${value} is not allowed as a JSON query value`, 400);
+    }
+    const escaped = value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+    const prefix = [
+        'like',
+        'not_like'
+    ].includes(operator ?? '') ? '(?i)' : '';
+    return `"${prefix}${escaped}"`;
+};
+export const createJSONQuery = ({ column, operator, pathSegments, value })=>{
+    const columnName = typeof column === 'object' ? column.name : column;
+    const jsonPaths = pathSegments.slice(1).map((key)=>{
+        return `${sanitizePathSegment(key)}[*]`;
+    }).join('.');
+    const fullPath = pathSegments.length === 1 ? '$[*]' : `$.${jsonPaths}`;
+    let sql = '';
+    if ([
+        'in',
+        'not_in'
+    ].includes(operator) && Array.isArray(value)) {
+        sql = '(';
+        value.forEach((item, i)=>{
+            sql = `${sql}${createJSONQuery({
+                column,
+                operator: operator === 'in' ? 'equals' : 'not_equals',
+                pathSegments,
+                value: item
+            })}${i === value.length - 1 ? '' : ` ${operator === 'in' ? 'OR' : 'AND'} `}`;
+        });
+        sql = `${sql})`;
+    } else if (operator === 'exists') {
+        sql = `${value === false ? 'NOT ' : ''}jsonb_path_exists(${columnName}, '${fullPath}')`;
+    } else if ([
+        'not_like'
+    ].includes(operator)) {
+        const mappedOperator = operatorMap[operator];
+        sql = `NOT jsonb_path_exists(${columnName}, '${fullPath} ? (@ ${mappedOperator.substring(1)} ${sanitizeValue(value, operator)})')`;
+    } else {
+        sql = `jsonb_path_exists(${columnName}, '${fullPath} ? (@ ${operatorMap[operator]} ${sanitizeValue(value, operator)})')`;
+    }
+    return sql;
+};
+
+//# sourceMappingURL=index.js.map

package/dist/postgres/createJSONQuery/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/postgres/createJSONQuery/index.ts"],"sourcesContent":["import { APIError } from '@hanzo/cms'\n\nimport type { CreateJSONQueryArgs } from '../../types.js'\n\nimport { SAFE_STRING_REGEX } from '../../utilities/escapeSQLValue.js'\nimport { sanitizePathSegment } from '../../utilities/sanitizePathSegment.js'\n\nconst operatorMap: Record<string, string> = {\n  contains: '~',\n  equals: '==',\n  in: 'in',\n  like: 'like_regex',\n  not_equals: '!=',\n  not_in: 'in',\n  not_like: '!like_regex',\n}\n\nconst sanitizeValue = (value: unknown, operator?: string): string => {\n  if (value === null) {\n    return `NULL`\n  }\n\n  if (typeof value === 'number' || typeof value === 'boolean') {\n    return `${value}`\n  }\n\n  if (typeof value !== 'string') {\n    throw new Error('Invalid value type')\n  }\n\n  if (!SAFE_STRING_REGEX.test(value)) {\n    throw new APIError(`${value} is not allowed as a JSON query value`, 400)\n  }\n\n  const escaped = value.replace(/\\\\/g, '\\\\\\\\').replace(/\"/g, '\\\\\"')\n\n  const prefix = ['like', 'not_like'].includes(operator ?? '') ? '(?i)' : ''\n\n  return `\"${prefix}${escaped}\"`\n}\n\nexport const createJSONQuery = ({ column, operator, pathSegments, value }: CreateJSONQueryArgs) => {\n  const columnName = typeof column === 'object' ? column.name : column\n  const jsonPaths = pathSegments\n    .slice(1)\n    .map((key) => {\n      return `${sanitizePathSegment(key)}[*]`\n    })\n    .join('.')\n\n  const fullPath = pathSegments.length === 1 ? '$[*]' : `$.${jsonPaths}`\n\n  let sql = ''\n\n  if (['in', 'not_in'].includes(operator) && Array.isArray(value)) {\n    sql = '('\n    value.forEach((item, i) => {\n      sql = `${sql}${createJSONQuery({ column, operator: operator === 'in' ? 'equals' : 'not_equals', pathSegments, value: item })}${i === value.length - 1 ? '' : ` ${operator === 'in' ? 'OR' : 'AND'} `}`\n    })\n    sql = `${sql})`\n  } else if (operator === 'exists') {\n    sql = `${value === false ? 'NOT ' : ''}jsonb_path_exists(${columnName}, '${fullPath}')`\n  } else if (['not_like'].includes(operator)) {\n    const mappedOperator = operatorMap[operator]\n\n    sql = `NOT jsonb_path_exists(${columnName}, '${fullPath} ? (@ ${mappedOperator.substring(1)} ${sanitizeValue(value, operator)})')`\n  } else {\n    sql = `jsonb_path_exists(${columnName}, '${fullPath} ? (@ ${operatorMap[operator]} ${sanitizeValue(value, operator)})')`\n  }\n\n  return sql\n}\n"],"names":["APIError","SAFE_STRING_REGEX","sanitizePathSegment","operatorMap","contains","equals","in","like","not_equals","not_in","not_like","sanitizeValue","value","operator","Error","test","escaped","replace","prefix","includes","createJSONQuery","column","pathSegments","columnName","name","jsonPaths","slice","map","key","join","fullPath","length","sql","Array","isArray","forEach","item","i","mappedOperator","substring"],"mappings":"AAAA,SAASA,QAAQ,QAAQ,aAAY;AAIrC,SAASC,iBAAiB,QAAQ,oCAAmC;AACrE,SAASC,mBAAmB,QAAQ,yCAAwC;AAE5E,MAAMC,cAAsC;IAC1CC,UAAU;IACVC,QAAQ;IACRC,IAAI;IACJC,MAAM;IACNC,YAAY;IACZC,QAAQ;IACRC,UAAU;AACZ;AAEA,MAAMC,gBAAgB,CAACC,OAAgBC;IACrC,IAAID,UAAU,MAAM;QAClB,OAAO,CAAC,IAAI,CAAC;IACf;IAEA,IAAI,OAAOA,UAAU,YAAY,OAAOA,UAAU,WAAW;QAC3D,OAAO,GAAGA,OAAO;IACnB;IAEA,IAAI,OAAOA,UAAU,UAAU;QAC7B,MAAM,IAAIE,MAAM;IAClB;IAEA,IAAI,CAACb,kBAAkBc,IAAI,CAACH,QAAQ;QAClC,MAAM,IAAIZ,SAAS,GAAGY,MAAM,qCAAqC,CAAC,EAAE;IACtE;IAEA,MAAMI,UAAUJ,MAAMK,OAAO,CAAC,OAAO,QAAQA,OAAO,CAAC,MAAM;IAE3D,MAAMC,SAAS;QAAC;QAAQ;KAAW,CAACC,QAAQ,CAACN,YAAY,MAAM,SAAS;IAExE,OAAO,CAAC,CAAC,EAAEK,SAASF,QAAQ,CAAC,CAAC;AAChC;AAEA,OAAO,MAAMI,kBAAkB,CAAC,EAAEC,MAAM,EAAER,QAAQ,EAAES,YAAY,EAAEV,KAAK,EAAuB;IAC5F,MAAMW,aAAa,OAAOF,WAAW,WAAWA,OAAOG,IAAI,GAAGH;IAC9D,MAAMI,YAAYH,aACfI,KAAK,CAAC,GACNC,GAAG,CAAC,CAACC;QACJ,OAAO,GAAG1B,oBAAoB0B,KAAK,GAAG,CAAC;IACzC,GACCC,IAAI,CAAC;IAER,MAAMC,WAAWR,aAAaS,MAAM,KAAK,IAAI,SAAS,CAAC,EAAE,EAAEN,WAAW;IAEtE,IAAIO,MAAM;IAEV,IAAI;QAAC;QAAM;KAAS,CAACb,QAAQ,CAACN,aAAaoB,MAAMC,OAAO,CAACtB,QAAQ;QAC/DoB,MAAM;QACNpB,MAAMuB,OAAO,CAAC,CAACC,MAAMC;YACnBL,MAAM,GAAGA,MAAMZ,gBAAgB;gBAAEC;gBAAQR,UAAUA,aAAa,OAAO,WAAW;gBAAcS;gBAAcV,OAAOwB;YAAK,KAAKC,MAAMzB,MAAMmB,MAAM,GAAG,IAAI,KAAK,CAAC,CAAC,EAAElB,aAAa,OAAO,OAAO,MAAM,CAAC,CAAC,EAAE;QACxM;QACAmB,MAAM,GAAGA,IAAI,CAAC,CAAC;IACjB,OAAO,IAAInB,aAAa,UAAU;QAChCmB,MAAM,GAAGpB,UAAU,QAAQ,SAAS,GAAG,kBAAkB,EAAEW,WAAW,GAAG,EAAEO,SAAS,EAAE,CAAC;IACzF,OAAO,IAAI;QAAC;KAAW,CAACX,QAAQ,CAACN,WAAW;QAC1C,MAAMyB,iBAAiBnC,WAAW,CAACU,SAAS;QAE5CmB,MAAM,CAAC,sBAAsB,EAAET,WAAW,GAAG,EAAEO,SAAS,MAAM,EAAEQ,eAAeC,SAAS,CAAC,GAAG,CAAC,EAAE5B,cAAcC,OAAOC,UAAU,GAAG,CAAC;IACpI,OAAO;QACLmB,MAAM,CAAC,kBAAkB,EAAET,WAAW,GAAG,EAAEO,SAAS,MAAM,EAAE3B,WAAW,CAACU,SAAS,CAAC,CAAC,EAAEF,cAAcC,OAAOC,UAAU,GAAG,CAAC;IAC1H;IAEA,OAAOmB;AACT,EAAC"}

package/dist/postgres/defaultSnapshot.d.ts

@@ -0,0 +1,3 @@
+import type { DrizzleSnapshotJSON } from 'drizzle-kit/api';
+export declare const defaultDrizzleSnapshot: DrizzleSnapshotJSON;
+//# sourceMappingURL=defaultSnapshot.d.ts.map

package/dist/postgres/defaultSnapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaultSnapshot.d.ts","sourceRoot":"","sources":["../../src/postgres/defaultSnapshot.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAA;AAE1D,eAAO,MAAM,sBAAsB,EAAE,mBAiBpC,CAAA"}

package/dist/postgres/defaultSnapshot.js

@@ -0,0 +1,20 @@
+export const defaultDrizzleSnapshot = {
+    id: '00000000-0000-0000-0000-000000000000',
+    _meta: {
+        columns: {},
+        schemas: {},
+        tables: {}
+    },
+    dialect: 'postgresql',
+    enums: {},
+    policies: {},
+    prevId: '00000000-0000-0000-0000-00000000000',
+    roles: {},
+    schemas: {},
+    sequences: {},
+    tables: {},
+    version: '7',
+    views: {}
+};
+
+//# sourceMappingURL=defaultSnapshot.js.map

package/dist/postgres/defaultSnapshot.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/postgres/defaultSnapshot.ts"],"sourcesContent":["import type { DrizzleSnapshotJSON } from 'drizzle-kit/api'\n\nexport const defaultDrizzleSnapshot: DrizzleSnapshotJSON = {\n  id: '00000000-0000-0000-0000-000000000000',\n  _meta: {\n    columns: {},\n    schemas: {},\n    tables: {},\n  },\n  dialect: 'postgresql',\n  enums: {},\n  policies: {},\n  prevId: '00000000-0000-0000-0000-00000000000',\n  roles: {},\n  schemas: {},\n  sequences: {},\n  tables: {},\n  version: '7',\n  views: {},\n}\n"],"names":["defaultDrizzleSnapshot","id","_meta","columns","schemas","tables","dialect","enums","policies","prevId","roles","sequences","version","views"],"mappings":"AAEA,OAAO,MAAMA,yBAA8C;IACzDC,IAAI;IACJC,OAAO;QACLC,SAAS,CAAC;QACVC,SAAS,CAAC;QACVC,QAAQ,CAAC;IACX;IACAC,SAAS;IACTC,OAAO,CAAC;IACRC,UAAU,CAAC;IACXC,QAAQ;IACRC,OAAO,CAAC;IACRN,SAAS,CAAC;IACVO,WAAW,CAAC;IACZN,QAAQ,CAAC;IACTO,SAAS;IACTC,OAAO,CAAC;AACV,EAAC"}

package/dist/postgres/deleteWhere.d.ts

@@ -0,0 +1,3 @@
+import type { DeleteWhere } from './types.js';
+export declare const deleteWhere: DeleteWhere;
+//# sourceMappingURL=deleteWhere.d.ts.map

package/dist/postgres/deleteWhere.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deleteWhere.d.ts","sourceRoot":"","sources":["../../src/postgres/deleteWhere.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAE7C,eAAO,MAAM,WAAW,EAAE,WAGzB,CAAA"}

package/dist/postgres/deleteWhere.js

@@ -0,0 +1,6 @@
+export const deleteWhere = async function deleteWhere({ db, tableName, where }) {
+    const table = this.tables[tableName];
+    await db.delete(table).where(where);
+};
+
+//# sourceMappingURL=deleteWhere.js.map

package/dist/postgres/deleteWhere.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/postgres/deleteWhere.ts"],"sourcesContent":["import type { TransactionPg } from '../types.js'\nimport type { DeleteWhere } from './types.js'\n\nexport const deleteWhere: DeleteWhere = async function deleteWhere({ db, tableName, where }) {\n  const table = this.tables[tableName]\n  await (db as TransactionPg).delete(table).where(where)\n}\n"],"names":["deleteWhere","db","tableName","where","table","tables","delete"],"mappings":"AAGA,OAAO,MAAMA,cAA2B,eAAeA,YAAY,EAAEC,EAAE,EAAEC,SAAS,EAAEC,KAAK,EAAE;IACzF,MAAMC,QAAQ,IAAI,CAACC,MAAM,CAACH,UAAU;IACpC,MAAM,AAACD,GAAqBK,MAAM,CAACF,OAAOD,KAAK,CAACA;AAClD,EAAC"}

package/dist/postgres/dropDatabase.d.ts

@@ -0,0 +1,3 @@
+import type { DropDatabase } from './types.js';
+export declare const dropDatabase: DropDatabase;
+//# sourceMappingURL=dropDatabase.d.ts.map

package/dist/postgres/dropDatabase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dropDatabase.d.ts","sourceRoot":"","sources":["../../src/postgres/dropDatabase.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAE9C,eAAO,MAAM,YAAY,EAAE,YAM1B,CAAA"}

package/dist/postgres/dropDatabase.js

@@ -0,0 +1,9 @@
+export const dropDatabase = async function dropDatabase({ adapter }) {
+    await adapter.execute({
+        drizzle: adapter.drizzle,
+        raw: `drop schema if exists ${this.schemaName || 'public'} cascade;
+    create schema ${this.schemaName || 'public'};`
+    });
+};
+
+//# sourceMappingURL=dropDatabase.js.map

package/dist/postgres/dropDatabase.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/postgres/dropDatabase.ts"],"sourcesContent":["import type { DropDatabase } from './types.js'\n\nexport const dropDatabase: DropDatabase = async function dropDatabase({ adapter }) {\n  await adapter.execute({\n    drizzle: adapter.drizzle,\n    raw: `drop schema if exists ${this.schemaName || 'public'} cascade;\n    create schema ${this.schemaName || 'public'};`,\n  })\n}\n"],"names":["dropDatabase","adapter","execute","drizzle","raw","schemaName"],"mappings":"AAEA,OAAO,MAAMA,eAA6B,eAAeA,aAAa,EAAEC,OAAO,EAAE;IAC/E,MAAMA,QAAQC,OAAO,CAAC;QACpBC,SAASF,QAAQE,OAAO;QACxBC,KAAK,CAAC,sBAAsB,EAAE,IAAI,CAACC,UAAU,IAAI,SAAS;kBAC5C,EAAE,IAAI,CAACA,UAAU,IAAI,SAAS,CAAC,CAAC;IAChD;AACF,EAAC"}

package/dist/postgres/execute.d.ts

@@ -0,0 +1,3 @@
+import type { Execute } from './types.js';
+export declare const execute: Execute<any>;
+//# sourceMappingURL=execute.d.ts.map

package/dist/postgres/execute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execute.d.ts","sourceRoot":"","sources":["../../src/postgres/execute.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAA;AAEzC,eAAO,MAAM,OAAO,EAAE,OAAO,CAAC,GAAG,CAQhC,CAAA"}

package/dist/postgres/execute.js

@@ -0,0 +1,11 @@
+import { sql } from 'drizzle-orm';
+export const execute = function execute({ db, drizzle, raw, sql: statement }) {
+    const executeFrom = db ?? drizzle;
+    if (raw) {
+        return executeFrom.execute(sql.raw(raw));
+    } else {
+        return executeFrom.execute(sql`${statement}`);
+    }
+};
+
+//# sourceMappingURL=execute.js.map

package/dist/postgres/execute.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/postgres/execute.ts"],"sourcesContent":["import { sql } from 'drizzle-orm'\n\nimport type { Execute } from './types.js'\n\nexport const execute: Execute<any> = function execute({ db, drizzle, raw, sql: statement }) {\n  const executeFrom = db ?? drizzle\n\n  if (raw) {\n    return executeFrom.execute(sql.raw(raw))\n  } else {\n    return executeFrom.execute(sql`${statement}`)\n  }\n}\n"],"names":["sql","execute","db","drizzle","raw","statement","executeFrom"],"mappings":"AAAA,SAASA,GAAG,QAAQ,cAAa;AAIjC,OAAO,MAAMC,UAAwB,SAASA,QAAQ,EAAEC,EAAE,EAAEC,OAAO,EAAEC,GAAG,EAAEJ,KAAKK,SAAS,EAAE;IACxF,MAAMC,cAAcJ,MAAMC;IAE1B,IAAIC,KAAK;QACP,OAAOE,YAAYL,OAAO,CAACD,IAAII,GAAG,CAACA;IACrC,OAAO;QACL,OAAOE,YAAYL,OAAO,CAACD,GAAG,CAAC,EAAEK,UAAU,CAAC;IAC9C;AACF,EAAC"}

package/dist/postgres/init.d.ts

@@ -0,0 +1,3 @@
+import type { Init } from '@hanzo/cms';
+export declare const init: Init;
+//# sourceMappingURL=init.d.ts.map

package/dist/postgres/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../src/postgres/init.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AAUtC,eAAO,MAAM,IAAI,EAAE,IAkClB,CAAA"}

package/dist/postgres/init.js

@@ -0,0 +1,41 @@
+import { buildDrizzleRelations } from '../schema/buildDrizzleRelations.js';
+import { buildRawSchema } from '../schema/buildRawSchema.js';
+import { executeSchemaHooks } from '../utilities/executeSchemaHooks.js';
+import { buildDrizzleTable } from './schema/buildDrizzleTable.js';
+import { setColumnID } from './schema/setColumnID.js';
+export const init = async function init() {
+    this.rawRelations = {};
+    this.rawTables = {};
+    buildRawSchema({
+        adapter: this,
+        setColumnID
+    });
+    await executeSchemaHooks({
+        type: 'beforeSchemaInit',
+        adapter: this
+    });
+    if (this.cms.config.localization) {
+        this.enums.enum__locales = this.pgSchema.enum('_locales', this.cms.config.localization.locales.map(({ code })=>code));
+    }
+    for(const tableName in this.rawTables){
+        buildDrizzleTable({
+            adapter: this,
+            rawTable: this.rawTables[tableName]
+        });
+    }
+    buildDrizzleRelations({
+        adapter: this
+    });
+    await executeSchemaHooks({
+        type: 'afterSchemaInit',
+        adapter: this
+    });
+    this.schema = {
+        pgSchema: this.pgSchema,
+        ...this.tables,
+        ...this.relations,
+        ...this.enums
+    };
+};
+
+//# sourceMappingURL=init.js.map

package/dist/postgres/init.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/postgres/init.ts"],"sourcesContent":["import type { Init } from '@hanzo/cms'\n\nimport type { BasePostgresAdapter } from './types.js'\n\nimport { buildDrizzleRelations } from '../schema/buildDrizzleRelations.js'\nimport { buildRawSchema } from '../schema/buildRawSchema.js'\nimport { executeSchemaHooks } from '../utilities/executeSchemaHooks.js'\nimport { buildDrizzleTable } from './schema/buildDrizzleTable.js'\nimport { setColumnID } from './schema/setColumnID.js'\n\nexport const init: Init = async function init(this: BasePostgresAdapter) {\n  this.rawRelations = {}\n  this.rawTables = {}\n\n  buildRawSchema({\n    adapter: this,\n    setColumnID,\n  })\n\n  await executeSchemaHooks({ type: 'beforeSchemaInit', adapter: this })\n\n  if (this.cms.config.localization) {\n    this.enums.enum__locales = this.pgSchema.enum(\n      '_locales',\n      this.cms.config.localization.locales.map(({ code }) => code) as [string, ...string[]],\n    )\n  }\n\n  for (const tableName in this.rawTables) {\n    buildDrizzleTable({ adapter: this, rawTable: this.rawTables[tableName] })\n  }\n\n  buildDrizzleRelations({\n    adapter: this,\n  })\n\n  await executeSchemaHooks({ type: 'afterSchemaInit', adapter: this })\n\n  this.schema = {\n    pgSchema: this.pgSchema,\n    ...this.tables,\n    ...this.relations,\n    ...this.enums,\n  }\n}\n"],"names":["buildDrizzleRelations","buildRawSchema","executeSchemaHooks","buildDrizzleTable","setColumnID","init","rawRelations","rawTables","adapter","type","cms","config","localization","enums","enum__locales","pgSchema","enum","locales","map","code","tableName","rawTable","schema","tables","relations"],"mappings":"AAIA,SAASA,qBAAqB,QAAQ,qCAAoC;AAC1E,SAASC,cAAc,QAAQ,8BAA6B;AAC5D,SAASC,kBAAkB,QAAQ,qCAAoC;AACvE,SAASC,iBAAiB,QAAQ,gCAA+B;AACjE,SAASC,WAAW,QAAQ,0BAAyB;AAErD,OAAO,MAAMC,OAAa,eAAeA;IACvC,IAAI,CAACC,YAAY,GAAG,CAAC;IACrB,IAAI,CAACC,SAAS,GAAG,CAAC;IAElBN,eAAe;QACbO,SAAS,IAAI;QACbJ;IACF;IAEA,MAAMF,mBAAmB;QAAEO,MAAM;QAAoBD,SAAS,IAAI;IAAC;IAEnE,IAAI,IAAI,CAACE,GAAG,CAACC,MAAM,CAACC,YAAY,EAAE;QAChC,IAAI,CAACC,KAAK,CAACC,aAAa,GAAG,IAAI,CAACC,QAAQ,CAACC,IAAI,CAC3C,YACA,IAAI,CAACN,GAAG,CAACC,MAAM,CAACC,YAAY,CAACK,OAAO,CAACC,GAAG,CAAC,CAAC,EAAEC,IAAI,EAAE,GAAKA;IAE3D;IAEA,IAAK,MAAMC,aAAa,IAAI,CAACb,SAAS,CAAE;QACtCJ,kBAAkB;YAAEK,SAAS,IAAI;YAAEa,UAAU,IAAI,CAACd,SAAS,CAACa,UAAU;QAAC;IACzE;IAEApB,sBAAsB;QACpBQ,SAAS,IAAI;IACf;IAEA,MAAMN,mBAAmB;QAAEO,MAAM;QAAmBD,SAAS,IAAI;IAAC;IAElE,IAAI,CAACc,MAAM,GAAG;QACZP,UAAU,IAAI,CAACA,QAAQ;QACvB,GAAG,IAAI,CAACQ,MAAM;QACd,GAAG,IAAI,CAACC,SAAS;QACjB,GAAG,IAAI,CAACX,KAAK;IACf;AACF,EAAC"}

package/dist/postgres/insert.d.ts

@@ -0,0 +1,3 @@
+import type { Insert } from './types.js';
+export declare const insert: Insert;
+//# sourceMappingURL=insert.d.ts.map

package/dist/postgres/insert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"insert.d.ts","sourceRoot":"","sources":["../../src/postgres/insert.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AAExC,eAAO,MAAM,MAAM,EAAE,MAoBpB,CAAA"}